home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / sml_nj / 93src.lha / src / runtime / mac / os_mac.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-02-09  |  70.7 KB  |  2,639 lines
  1. /* os_mac.c
  2.  * 12Sep92  e  adapted from the file of the same name in the Gambit Project
  3.  * Macintosh specific stuff (for THINK C 5.0.1 compiler).
  4.  * portions Copyright ⌐ 1992 Marc Feeley and Douglas H. Currie, Jr.
  5.  */
  6.  
  7. #include <MacHeaders>
  8.  
  9. #include "os_mac.h"
  10. #include <stdio.h>
  11. #include <errno.h>
  12. #include <signal.h>
  13.  
  14. #define use_MacTraps2 (1)
  15.  
  16. /*---------------------------------------------------------------------------*/
  17.  
  18. /* new stuff  29Dec92  e  */
  19.  
  20. #include <GestaltEqu.h>
  21. #include <AppleEvents.h>
  22.  
  23. /* 1Feb93  e */
  24. #ifdef THINK_C
  25. #undef kAERestart
  26. #undef kAEShutDown
  27. #endif
  28. #include <AERegistry.h>
  29.  
  30. static void init_ae();
  31.  
  32. Boolean        gDoQuit = false;
  33. Boolean        gHasAppleEvents = false;
  34. Boolean        gPrintPage = false;
  35. Boolean        spareB1;
  36.  
  37. #include "eventchk.h"        /* 25Jan93  e */
  38. long next_eventchk_ticks;    /* 25Jan93  e */
  39.  
  40. /*---------------------------------------------------------------------------*/
  41.  
  42. TextStyle prefStylNormal =
  43. { monaco, 0, 0, FontSize, { 65536, 65536, 65536 } /* RGBColor Black */ };
  44. TextStyle prefStylHilite =
  45. { monaco, 0, 0, FontSize, { 65536, 65536, 65536 } /* RGBColor Black */ };
  46.  
  47. short prefTabs = dfltTabs;
  48. short prefWrap = dfltWrap;
  49. short prefAutoInd = dfltAutoInd;
  50.  
  51. short current_menus;
  52.  
  53. MenuHandle menus[7];        /* 10Jan93  e */
  54.  
  55. Cursor watch_cursor;
  56. Cursor gc_cursor;
  57. Cursor ibeam_cursor;
  58. Cursor *current_cursor;
  59.  
  60. unsigned char *find_string, *replace_string;
  61.  
  62. Boolean find_ci   = FALSE;
  63. Boolean find_wrap = FALSE;
  64.  
  65. static Boolean smKeyBdP;
  66. static Boolean showPosnP;    /* 10Jan93  e */
  67.  
  68. short interaction_id = 0;
  69. short abnormal_exit = 0;
  70. short interrupted = 0;
  71. short current_volume = 0;
  72.  
  73. static struct {
  74.   short in_use;
  75.   short bold_input;
  76.   WindowPtr wptr;
  77.   ControlHandle vscroll;
  78.   ControlHandle hscroll;
  79.   TeHANDLE hTE;
  80.   short height;
  81.   short dirty;
  82.   short pos, len;
  83.   char *buf;
  84.   Handle out_buf;
  85.   short out_len;
  86.   short is_file;
  87.   unsigned char *filename;
  88.   long needs_inval_ticks;            /* 10Jan93  e --  display of caret position */
  89.   } wind_table[MAX_NB_WINDOWS];
  90.  
  91. static void io_err( short io );
  92.  
  93. #if 0
  94.  
  95. static struct
  96. { char   *a5;
  97.   VBLTask task;
  98. } et;
  99.  
  100. static void intr_task()
  101. { asm
  102.   { move.l a5,-(sp)
  103.     move.l -4(a0),a5
  104.     
  105.     cmpa.l 0x904,a5
  106.     beq.s @goon
  107.     _Debugger
  108. goon:
  109.   }
  110.   if (intr_task_interval > 0)
  111.   { timer_action( 0L, 0L, 1L );
  112.     et.task.vblCount = intr_task_interval;
  113.   }
  114.   else
  115.     et.task.vblCount = 1;
  116.   asm
  117.   { move.l (sp)+,a5
  118.   }
  119. }
  120.  
  121. static void start_intr_task()
  122. { asm
  123.   { move.l a5,et.a5
  124.   }
  125.   et.task.qType    = vType;
  126.   et.task.vblAddr  = (ProcPtr)intr_task;
  127.   et.task.vblCount = 1;
  128.   et.task.vblPhase = 0;
  129.   intr_task_installed = (VInstall( (QElemPtr )&et.task ) == noErr);
  130. }
  131.  
  132. static void stop_intr_task()
  133. { if (intr_task_installed)
  134.   { VRemove( (QElemPtr )&et.task ); intr_task_installed = 0; }
  135. }
  136.  
  137. #endif
  138.  
  139. RgnHandle gCursorRgn;
  140. Boolean gHasWNE = true;
  141. Boolean gHasHWPriv = true;
  142. Boolean gCursRgnOK = false;
  143. Boolean gInBackground = false;
  144. long gWaitTicksBG = 5; /* in ticks,  should be 1..15 */
  145. long gWaitTicksFG = 1; /* in ticks,  should be 1..15 */
  146. /** Define trap numbers **/
  147. #ifndef _Unimplemented
  148. #define _Unimplemented 0xA89F /* Unimplemented trap */
  149. #endif
  150. #ifndef _WaitNextEvent
  151. #define _WaitNextEvent 0xA860 /* WaitNextEvent trap */
  152. #endif
  153. #ifndef _HWPriv
  154. #define _HWPriv 0xA098 /* HWPriv trap */
  155. #endif
  156.  
  157. TrapType GetTrapType(short theTrap)
  158. { /* OS traps start with A0, Tool with A8 or AA. */
  159.   if ((theTrap & 0x0800) == 0)
  160.     return (OSTrap);
  161.   else
  162.     return (ToolTrap);
  163. }
  164. short NumToolboxTraps(void)
  165. { /* InitGraf (trap $A86E) is always implemented. */
  166.   if (NGetTrapAddress(0xA86E, ToolTrap) == NGetTrapAddress(0xAA6E, ToolTrap))
  167.     return (0x200);
  168.   else
  169.     return (0x400);
  170. }
  171. Boolean TrapExists(short theTrap)
  172. { TrapType theTrapType;
  173.   theTrapType = GetTrapType(theTrap);
  174.   if ((theTrapType == ToolTrap) && ((theTrap &= 0x07FF) >= NumToolboxTraps()))
  175.     theTrap = _Unimplemented;
  176.   return (NGetTrapAddress(_Unimplemented, ToolTrap) != NGetTrapAddress(theTrap, theTrapType));
  177. }
  178.  
  179. static void setup_cursors()
  180. { CursHandle hCurs;
  181.   hCurs = GetCursor(watchCursor);
  182.   watch_cursor = **hCurs;
  183.   /* 28Jan93  e
  184.   hCurs = GetCursor(gc_cursorID);
  185.   gc_cursor = **hCurs;
  186.   */
  187.   hCurs = GetCursor(iBeamCursor);
  188.   ibeam_cursor = **hCurs;
  189.  
  190.   current_cursor = &watch_cursor;
  191. }
  192.  
  193. /* 02Oct92  e  added ParamText1 */
  194.  
  195. static void ParamText1( Str255 text )
  196. {
  197.     ParamText( text, "\p", "\p", "\p" );
  198. }
  199.  
  200. static void c_to_p( c_str, p_str )
  201. char *c_str;
  202. Str255 p_str;
  203. { short i = 0;
  204.   while (c_str[i] != '\0') { p_str[i+1] = c_str[i]; i++; }
  205.   p_str[0] = i;
  206. }
  207.  
  208. static void p_to_p( p1, p2 )
  209. Str255 p1, p2;
  210. { short len = (unsigned char)*p1++;
  211.   *p2++ = len;
  212.   while (len>0) { *p2++ = *p1++; len--; }
  213. }
  214.  
  215. static void buf_to_p( unsigned short len, char *p1, Str255 p2 )
  216. { if( len > 255 ) len = 255;
  217.   *p2++ = len;
  218.   while (len>0) { *p2++ = *p1++; len--; }
  219. }
  220.  
  221. static void p_to_c( p_str, c_str )
  222. Str255 p_str;
  223. char *c_str;
  224. { short len = (unsigned char)*p_str++, i = 0;
  225.   while (i<len) { *c_str++ = *p_str++; i++; }
  226.   *c_str++ = '\0';
  227. }
  228.  
  229. static short compare_p_to_p( p1, p2 )
  230. Str255 p1, p2;
  231. { short len1 = (unsigned char)*p1++, len2 = (unsigned char)*p2++;
  232.   if (len1 < len2) return -1;
  233.   if (len1 > len2) return 1;
  234.   while (len1>0)
  235.   { short c1 = (unsigned char)*p1++, c2 = (unsigned char)*p2++;
  236.     if (c1 < c2) return -1;
  237.     if (c1 > c2) return 1;
  238.     len1--;
  239.   }
  240.   return 0;
  241. }
  242.  
  243. static void pathstr_to_filename( register Str255 p_str, Str255 f_str )
  244. {    register short plen = p_str[0];
  245.     while( plen && p_str[plen] != ':' ) plen--;
  246.     buf_to_p( p_str[0] - plen, (char *)&p_str[plen+1], f_str );
  247. }
  248.  
  249. /* *** preferences saved to disk *** */
  250.  
  251. #ifdef use_MacTraps2
  252.  
  253. static OSErr findPrefFolder( short *foundVRefNum, long *foundDirID )
  254. {    
  255.   *foundVRefNum = 0;
  256.   *foundDirID = 0;
  257.   /* MacTraps2 has FindFolder() glue */
  258.   return FindFolder( kOnSystemDisk, kPreferencesFolderType, kCreateFolder,
  259.                        foundVRefNum, foundDirID );
  260. }
  261.  
  262. #else
  263.  
  264. #include <GestaltEqu.h>
  265.  
  266. #define BTstQ(arg, bitnbr)        (arg & (1 << bitnbr))
  267.  
  268. static OSErr findPrefFolder( short *foundVRefNum, long *foundDirID )
  269. {
  270.   long          gesResponse;
  271.   SysEnvRec     envRec;
  272.   WDPBRec       myWDPB;
  273.   unsigned char volName[34];
  274.   OSErr         err;
  275.     
  276.   *foundVRefNum = 0;
  277.   *foundDirID = 0;
  278.   if ( !Gestalt( gestaltFindFolderAttr, &gesResponse ) 
  279.           && BTstQ( gesResponse, gestaltFindFolderPresent ) )
  280.   { /* Folder Manager exists */
  281.     err = FindFolder( kOnSystemDisk, kPreferencesFolderType, kCreateFolder,
  282.                        foundVRefNum, foundDirID );
  283.   }
  284.   else
  285.   { /* Gestalt can't give us the answer, so we resort to SysEnvirons */
  286.     if ( !(err = SysEnvirons( curSysEnvVers, &envRec )) )
  287.     {  myWDPB.ioVRefNum = envRec.sysVRefNum;
  288.        volName[0] = '\000';                   /* Zero volume name */
  289.        myWDPB.ioNamePtr = volName;
  290.        myWDPB.ioWDIndex = 0;
  291.        myWDPB.ioWDProcID = 0;
  292.        if ( !(err = PBGetWDInfo( &myWDPB, 0 )) )
  293.        { *foundVRefNum = myWDPB.ioWDVRefNum;
  294.          *foundDirID = myWDPB.ioWDDirID;
  295.        }
  296.     }
  297.   }
  298.   return (err);
  299. }
  300.  
  301. #endif
  302.  
  303. struct prefs
  304. { short version;
  305.   short tabs;
  306.   short wrap;
  307.   Boolean find_ci;
  308.   Boolean find_wrap;
  309.   Boolean spare0;        /* smKeyBdP in Gambit */
  310.   Boolean showPosnP;    /* 10Jan93  e  */
  311.   short spare2;
  312.   short spare3;
  313.   short autoInd;
  314.   TextStyle stylNormal;
  315.   TextStyle stylHilite;
  316.   unsigned char fontnmNormal[64];
  317.   unsigned char fontnmHilite[64];
  318. };
  319.  
  320. void savePrefs( ConstStr255Param fn )
  321. {
  322.     short rRef;
  323.       OSErr err;
  324.     struct prefs **hRes;
  325.     struct prefs  *pRes;
  326.     short foundVRefNum;
  327.     long  foundDirID;
  328.     Str255 fontnmNormal, fontnmHilite;
  329.     
  330.     err = findPrefFolder( &foundVRefNum, &foundDirID );
  331.     if( err != noErr ) return;
  332.     
  333.     if( ( rRef = HOpenResFile( foundVRefNum, foundDirID, fn, fsRdWrPerm ) ) < 0)
  334.     {    HCreateResFile( foundVRefNum, foundDirID, fn );
  335.         { HFileInfo pb;
  336.           pb.ioCompletion = (void *)0;
  337.           pb.ioNamePtr = (StringPtr )fn;
  338.           pb.ioVRefNum = foundVRefNum;
  339.           pb.ioFDirIndex = 0;
  340.           pb.ioDirID = foundDirID;
  341.           err = PBHGetFInfo( &pb, FALSE );
  342.           pb.ioCompletion = (void *)0;
  343.           pb.ioNamePtr = (StringPtr )fn;
  344.           pb.ioVRefNum = foundVRefNum;
  345.           pb.ioFDirIndex = 0;
  346.           pb.ioDirID = foundDirID;
  347.           pb.ioFlFndrInfo.fdCreator = 'NJML'; /* 14Dec92  e  */
  348.           pb.ioFlFndrInfo.fdType    = 'gamP';
  349.           if( err == noErr )
  350.             PBHSetFInfo( &pb, FALSE );
  351.         }
  352.         rRef = HOpenResFile( foundVRefNum, foundDirID, fn, fsRdWrPerm );
  353.     }
  354.     if( rRef < 0 )
  355.         return;
  356.     hRes = (struct prefs **)GetResource('ePrf', 357);
  357.     if(    hRes == 0 || rRef != HomeResFile( (Handle )hRes ) )
  358.     {    hRes = (struct prefs **)NewHandle( sizeof( struct prefs ) );
  359.         if( hRes == 0 )
  360.         {    CloseResFile( rRef );
  361.             return;
  362.         }
  363.         AddResource( (Handle )hRes, (ResType )'ePrf', 357, (ConstStr255Param)"\p" );
  364.         if( ResErr != noErr )
  365.         {    DisposHandle( (Handle )hRes );
  366.             CloseResFile( rRef );
  367.             return;
  368.         }
  369.     }
  370.     pRes = *hRes;
  371.     (*pRes).version    = 1;
  372.     (*pRes).tabs       = prefTabs;
  373.     (*pRes).wrap       = prefWrap;
  374.     (*pRes).find_ci    = find_ci;
  375.     (*pRes).find_wrap  = find_wrap;
  376.     (*pRes).spare0     = 0;
  377.     (*pRes).showPosnP  = showPosnP;        /* 10Jan93  e  */
  378.     (*pRes).spare2     = 0;
  379.     (*pRes).spare3     = 0;
  380.     (*pRes).autoInd    = prefAutoInd;
  381.     (*pRes).stylNormal = prefStylNormal;
  382.     (*pRes).stylHilite = prefStylHilite;
  383.     GetFontName( prefStylNormal.tsFont, fontnmNormal );
  384.     if( fontnmNormal[0] > 63 ) fontnmNormal[0] = 63;
  385.     p_to_p( fontnmNormal, (**hRes).fontnmNormal );
  386.     GetFontName( prefStylHilite.tsFont, fontnmHilite );
  387.     if( fontnmHilite[0] > 63 ) fontnmHilite[0] = 63;
  388.     p_to_p( fontnmHilite, (**hRes).fontnmHilite );
  389.     
  390.     ChangedResource( (Handle )hRes );
  391.     CloseResFile( rRef );
  392. }
  393.  
  394. static void readPrefs( ConstStr255Param fn )
  395. {
  396.     short rRef;
  397.       OSErr err;
  398.     struct prefs **hRes;
  399.     struct prefs  *pRes;
  400.     short foundVRefNum;
  401.     long  foundDirID;
  402.     short    fontNumber;
  403.  
  404.     err = findPrefFolder( &foundVRefNum, &foundDirID );
  405.     if( err != noErr ) return;
  406.     
  407.     rRef = HOpenResFile( foundVRefNum, foundDirID, fn, fsRdWrPerm );
  408.     /* don't test rRef here since resource may come from elsewhere, e.g., from appl. */
  409.     hRes = (struct prefs **)GetResource('ePrf', 357);
  410.     if(    hRes != 0 )
  411.     {    pRes = *hRes;
  412.         if( (*pRes).version == 1 )
  413.         {    prefTabs   = (*pRes).tabs;
  414.             prefWrap   = (*pRes).wrap;
  415.             find_ci    = (*pRes).find_ci;
  416.             find_wrap  = (*pRes).find_wrap;
  417.             prefAutoInd = (*pRes).autoInd;
  418.             showPosnP  = (*pRes).showPosnP;    /* 10Jan93  e  */
  419.             prefStylNormal = (*pRes).stylNormal;
  420.             prefStylHilite = (*pRes).stylHilite;
  421.             GetFNum( (**hRes).fontnmNormal, &prefStylNormal.tsFont );
  422.             if( prefStylNormal.tsFont < 0 ) prefStylNormal.tsFont = 0;
  423.             GetFNum( (**hRes).fontnmHilite, &prefStylHilite.tsFont );
  424.             if( prefStylHilite.tsFont < 0 ) prefStylHilite.tsFont = 0;
  425.         }
  426.     }
  427.     if( rRef >= 0 ) CloseResFile( rRef );
  428. }
  429.  
  430. /* *** */
  431.  
  432. #define fustItem 3
  433. static short itemtowindid[MAX_NB_WINDOWS];
  434. static short windidtodigit[MAX_NB_WINDOWS];
  435. static short qWindItems = 0;
  436.  
  437. typedef struct { short nbmenus6, right, dummy; struct { MenuHandle mh; short left; } menu[100]; } menu_list;
  438.  
  439. static short cmd_key_exists( c )
  440. char c;
  441. {
  442.   menu_list **ml = (menu_list **)MenuList;
  443.   short n = (*ml)->nbmenus6/6;
  444.   short i, j, m, cmd;
  445.   for (i=0; i<n; i++)
  446.   { MenuHandle mh = (*ml)->menu[i].mh;
  447.     m = CountMItems( mh );
  448.     for (j=1; j <= m; j++)
  449.     {
  450.       GetItemCmd( mh, j, &cmd );
  451.       if (cmd == c) return 1;
  452.     }
  453.   }
  454.   return 0;
  455. }
  456.  
  457. static void addWindMenuItem( short id )
  458. {    short d, i, j;
  459.     Str255 title, key = "\p / ";
  460.     WindowPtr wind = wind_table[id].wptr;
  461.     if (qWindItems >= MAX_NB_WINDOWS) return;
  462.     for (d=1; d<10; d++) if (!cmd_key_exists('0'+d)) break;
  463.     if (d < 10) key[3] = '0'+d; else key[2] = ' ';
  464.     windidtodigit[id] = d;
  465.     for (i=0; i < qWindItems; i++)
  466.       if (windidtodigit[itemtowindid[i]] > d) break;
  467.     for (j=qWindItems-1; j > i; j--)
  468.       itemtowindid[j] = itemtowindid[j-1];
  469.     itemtowindid[i] = id;
  470.     GetWTitle( wind, title );
  471.     InsMenuItem( menus[windowsM], key, i+fustItem-1 );
  472.     SetItem( menus[windowsM], i+fustItem, title );
  473.     qWindItems++;
  474. }
  475.  
  476. static void delWindMenuItem( short id )
  477. {    register short i;
  478.     for(i = 0; i < qWindItems; i++)
  479.     {    if( id == itemtowindid[i] )
  480.         {    DelMenuItem( menus[windowsM], i+fustItem );
  481.             for( i++; i < qWindItems; i++ )
  482.                 itemtowindid[i-1] = itemtowindid[i];
  483.             qWindItems--;
  484.             break;
  485.         }
  486.     }
  487. }
  488.  
  489. void eSmudgeWindow( register short w )
  490. {    register short i;
  491.     if( ! wind_table[w].dirty )
  492.     {    wind_table[w].dirty = 1;
  493.         for( i = 0; i < qWindItems; i++ )
  494.         {    if( w == itemtowindid[i] )
  495.             {    SetItemMark( menus[windowsM], i+fustItem, '╫');
  496.                 break;
  497.             }
  498.         }
  499.     }
  500. }
  501.  
  502. void eUnSmudgeWindow( register short w, TeHANDLE hTE )
  503. {    register short i;
  504.     (**hTE).dirty = 0;
  505.     if( wind_table[w].dirty )
  506.     {    wind_table[w].dirty = 0;
  507.         for( i = 0; i < qWindItems; i++ )
  508.         {    if( w == itemtowindid[i] )
  509.             {    SetItemMark( menus[windowsM], i+fustItem, 0);
  510.                 break;
  511.             }
  512.         }
  513.     }
  514. }
  515.  
  516. void eMaybeSmudgeWindow( short w, TeHANDLE hTE )
  517. {
  518.     if( (**hTE).dirty )
  519.         eSmudgeWindow( w );
  520.     else
  521.         eUnSmudgeWindow( w, hTE );    /* for Undo  14Aug92  e  */
  522. }
  523.  
  524. void select_and_show( wptr )
  525. WindowPtr wptr;
  526. {
  527.   SelectWindow( wptr );
  528.   ShowWindow( wptr );
  529. }
  530.  
  531. /* ************* */
  532.  
  533. /* 10Jan93  e  -- separated out Search menu */
  534.  
  535. static void wind_begin()
  536. { short i;
  537.   for (i=0; i<MAX_NB_WINDOWS; i++) wind_table[i].in_use = 0;
  538.   InitGraf( &thePort );
  539.   InitFonts();
  540.   FlushEvents( everyEvent, 0 );
  541.   InitWindows();
  542.   InitMenus();
  543.   TEInit();
  544.   eTeInit();
  545.   InitDialogs( 0L );
  546.   InitCursor();
  547.  
  548.   prefStylHilite.tsFace = bold+condense;
  549.  
  550.   menus[appleM] = GetMenu( appleID );
  551.   AddResMenu( menus[appleM], 'DRVR' );
  552.   menus[fileM]    = GetMenu( fileID );
  553.   menus[editM]    = GetMenu( editID );
  554.   menus[findM]    = GetMenu( findID );
  555.   menus[commandM] = GetMenu( commandID );
  556.   menus[windowsM] = GetMenu( windowsID );
  557.  
  558.   ClearMenuBar();
  559.   for ( (i=appleM); (i<=windowsM); i++ ) InsertMenu(menus[i], 0);
  560.   DrawMenuBar();
  561.   current_menus = 0;
  562.  
  563.   setup_cursors();
  564.  
  565.   find_string =    (unsigned char *)NewPtr( 256 );
  566.   replace_string = (unsigned char *)NewPtr( 256 );
  567.   if( find_string == NULL || replace_string == NULL )
  568.   {    SysBeep(10);
  569.       os_quit();
  570.   }
  571.   find_string[0] = '\0';
  572.   replace_string[0] = '\0';
  573.  
  574.   gCursorRgn = NewRgn();
  575.   SetRectRgn(gCursorRgn, -32768, -32768, 32766, 32766);
  576.   gHasWNE = TrapExists(_WaitNextEvent);
  577.  
  578.   gHasHWPriv = TrapExists(_HWPriv);
  579.  
  580.   readPrefs( PREFS_FILENAME );
  581.  
  582.   init_ae();    /* 29Dec92  e  */
  583. }
  584.  
  585. static void wind_close( id )
  586. short id;
  587. { TeHANDLE hTE = wind_table[id].hTE;
  588.   if (id == interaction_id)
  589.   { HideWindow( wind_table[id].wptr );
  590.     eTeSetSelect( hTE, 0, eTeTextLength( hTE ));
  591.     eTeDelete( hTE );
  592.   }
  593.   else if (wind_table[id].in_use)
  594.   { wind_table[id].in_use = 0;
  595.     HideWindow( wind_table[id].wptr );
  596.     eTeDispose( hTE );
  597.     delWindMenuItem( id );
  598.     DisposeControl( wind_table[id].vscroll );
  599.     DisposeControl( wind_table[id].hscroll );
  600.     DisposeWindow( wind_table[id].wptr );
  601.     if (wind_table[id].buf != NULL)
  602.     { DisposPtr( wind_table[id].buf ); wind_table[id].buf = NULL; }
  603.     if( wind_table[id].out_buf != NULL )
  604.     { DisposHandle( wind_table[id].out_buf ); wind_table[id].out_buf = NULL; }
  605.     if( wind_table[id].filename != NULL )
  606.     { DisposPtr( wind_table[id].filename ); wind_table[id].filename = NULL; }
  607.   }
  608. }
  609.  
  610. static void wind_end()
  611. { short id;
  612.   for (id=MAX_NB_WINDOWS-1; id>=0; id--) wind_close( id );
  613.   eTePutScrap();    /* 27Jan93  e */
  614. }
  615.  
  616. static pascal click_scroll();
  617.  
  618. static short wind_open( name, visible, goaway, bold_input )
  619. char *name;
  620. short visible, goaway, bold_input;
  621. { Rect viewRect, vScrollRect, bounds;
  622.   short width = 80 /*(screenBits.bounds.right-SBarWidth-2*Border-11)/FontW*/;
  623.   short height;
  624.   short id;
  625.   Str255 wname;
  626.  
  627.   for (id=0; id<MAX_NB_WINDOWS; id++) if (!wind_table[id].in_use) break;
  628.   if (id == MAX_NB_WINDOWS) return -1;
  629.  
  630.   height = (screenBits.bounds.bottom-Border-48-SBarWidth)/FontH - id;
  631.  
  632.   bounds.left   = 3 + id*5;
  633.   bounds.right  = bounds.left + width*FontW + SBarWidth + Border;
  634.   bounds.top    = 41 + id*(FontH+3);
  635.   bounds.bottom = bounds.top + height*FontH + SBarWidth + Border;
  636.  
  637.   c_to_p( name, wname );
  638.  
  639.   wind_table[id].wptr = (WindowPtr )
  640.     NewWindow( NULL, &bounds, wname, visible, documentProc, (WindowPtr)-1L, goaway, 0L );
  641.   if (wind_table[id].wptr == NULL) return -1;
  642.  
  643.   SetPort( wind_table[id].wptr );
  644.   TextFont( prefStylNormal.tsFont );
  645.   TextSize( prefStylNormal.tsSize );
  646.  
  647.   vScrollRect = (*wind_table[id].wptr).portRect;
  648.   vScrollRect.left = vScrollRect.right-SBarWidth;
  649.   vScrollRect.right += 1;
  650.   vScrollRect.bottom -= SBarWidth-1;
  651.   vScrollRect.top -= 1;
  652.  
  653.   wind_table[id].vscroll =
  654.     NewControl( wind_table[id].wptr, &vScrollRect, "\p", 1, 0, 0, 0,
  655.                 scrollBarProc, 0L);
  656.  
  657.   if (wind_table[id].vscroll != NULL)
  658.   { static FontInfo fInfo;
  659.  
  660.     vScrollRect = (*wind_table[id].wptr).portRect;
  661.     vScrollRect.top = vScrollRect.bottom-SBarWidth;
  662.     vScrollRect.bottom += 1;
  663.     vScrollRect.left += (vScrollRect.right-vScrollRect.left)>>1;
  664.     vScrollRect.right -= SBarWidth-1;
  665.     wind_table[id].hscroll =
  666.       NewControl( wind_table[id].wptr, &vScrollRect, "\p", 1, 0, 0, 0,
  667.                 scrollBarProc, 0L);
  668.     if (wind_table[id].hscroll != NULL)
  669.     {
  670.  
  671.       viewRect = (*wind_table[id].wptr).portRect;
  672.       viewRect.top    += Border;
  673.       viewRect.left   += Border;
  674.       viewRect.bottom -= SBarWidth;
  675.       viewRect.right  -= SBarWidth;
  676.  
  677.       wind_table[id].hTE = eTeNew( wind_table[id].wptr, viewRect, prefTabs, prefWrap,
  678.                                       prefAutoInd, wind_table[id].hscroll, wind_table[id].vscroll );
  679.  
  680.       if (wind_table[id].hTE != NULL)
  681.       {
  682.         eTeSetStyles( wind_table[id].hTE, &prefStylNormal, &prefStylHilite );
  683.         wind_table[id].height     = height;
  684.         wind_table[id].bold_input = bold_input;
  685.         wind_table[id].dirty      = 0;
  686.         wind_table[id].pos        = 0;
  687.         wind_table[id].len        = 0;
  688.         wind_table[id].buf        = NULL;
  689.         wind_table[id].out_buf    = NULL;
  690.         wind_table[id].out_len    = 0;
  691.         wind_table[id].is_file    = 0;
  692.         wind_table[id].filename   = (unsigned char *)NewPtr( FILENAME_LEN );
  693.         if( wind_table[id].filename != NULL )
  694.         { wind_table[id].filename[0] = '\0';
  695.           wind_table[id].in_use   = 1;
  696.           addWindMenuItem( id );
  697.           return id;
  698.         }
  699.         eTeDispose( wind_table[id].hTE );
  700.       }
  701.       DisposeControl( wind_table[id].hscroll );
  702.     }
  703.     DisposeControl( wind_table[id].vscroll );
  704.   }
  705.   DisposeWindow( wind_table[id].wptr );
  706.   return -1;
  707. }
  708.  
  709. static short discard_changes( id )
  710. short id;
  711. { Str255 title;
  712.   GetWTitle( wind_table[id].wptr, title );
  713.   ParamText( "\pDiscard changes to \"", title, "\p\"?", "\p" );
  714.   SysBeep( 10 );
  715.   switch (CautionAlert( ok_cancel_alertID, 0L ))
  716.   { case 3: return 1;
  717.     default: return 0;
  718.   }
  719. }
  720.  
  721. static short mem_full = 0;
  722. static short supress_mem_full_dialog = 0;        /* 27Jan93  e  */
  723.  
  724. pascal long mem_full_err( size )
  725. long size;
  726. { if (mem_full)
  727.   { ParamText1( "\pOut of memory.  The application will exit." );
  728.     SysBeep( 10 );
  729.     StopAlert( ok_alertID, 0L );
  730.     ExitToShell();
  731.   }
  732.   mem_full = 1;
  733.   if ( ! supress_mem_full_dialog )            /* 27Jan93  e  */
  734.   { ParamText1( "\pOut of memory." );
  735.     SysBeep( 10 );
  736.     StopAlert( ok_alertID, 0L );
  737.   }
  738.   return 0;
  739. }
  740.  
  741. static void already_open_err( name )
  742. Str255 name;
  743. { ParamText( "\p\"", name, "\p\"", "\pis already open.  Close it first." );
  744.   SysBeep( 10 );
  745.   StopAlert( ok_alertID, 0L );
  746. }
  747.  
  748. static void path_too_long_err( name )
  749. Str255 name;
  750. { ParamText( "\pPath to file \"", name, "\p\" is too long.", "\p" );
  751.   SysBeep( 10 );
  752.   StopAlert( ok_alertID, 0L );
  753. }
  754.  
  755. static void wind_err()
  756. { ParamText1( "\pCan't open window" );
  757.   SysBeep( 10 );
  758.   StopAlert( ok_alertID, 0L );
  759. }
  760.  
  761. /* 02Oct92  e  added Printer Not Found check, error number displayed for other errors */
  762.  
  763. static void io_err( short io )
  764. { unsigned char errnostr[16];
  765.   switch (io)
  766.   { case wrPermErr    : ParamText1( "\pCan't write file!" ); break;
  767.     case dupFNErr     : ParamText1( "\pDuplicate file name!" ); break;
  768.     case fBsyErr      : ParamText1( "\pFile is busy!" ); break;
  769.     case vLckdErr     : ParamText1( "\pVolume is locked!" ); break;
  770.     case fLckdErr     : ParamText1( "\pFile is locked!" ); break;
  771.     case fnfErr       : ParamText1( "\pFile not found!" ); break;
  772.     case bdNamErr     : ParamText1( "\pBad filename!" ); break;
  773.     case ioErr        : ParamText1( "\pIO transfer error!" ); break;
  774.     case dskFulErr    : ParamText1( "\pDisk full!" ); break;
  775.     case dirFulErr    : ParamText1( "\pDirectory full!" ); break;
  776.     case mFulErr      : ParamText1( "\pFile is too large for memory!" ); break;
  777.                         
  778.     case -4101          : ParamText1( "\pNo printer selected. Use the Chooser." ); break;
  779.     default           : NumToString( io, errnostr );
  780.                         ParamText( "\pIO Error! Mac error number: ", errnostr, "\p", "\p" );
  781.                         break;
  782.   }
  783.   SysBeep( 10 );
  784.   StopAlert( ok_alertID, 0L );
  785. }
  786.  
  787. static void te_limit_err()
  788. { ParamText1( "\pFile unopened due to size limit on buffer (32000 lines)." );
  789.   SysBeep( 10 );
  790.   StopAlert( ok_alertID, 0L );
  791. }
  792.  
  793. static short check_TEWrite( ptr, len, hTE, bold )
  794. char *ptr;
  795. long len;
  796. eTeHandle hTE;
  797. short bold;
  798. {    eTeWrite( hTE, ptr, len, bold );
  799.     if (mem_full) { mem_full = 0; return 1; }
  800.     return 0;
  801. }
  802.  
  803. /* 23Jul92  e  exported for eKeys */
  804. short check_TEInsert( ptr, len, hTE, bold )
  805. char *ptr;
  806. long len;
  807. eTeHandle hTE;
  808. short bold;
  809. {    eTeInsert( hTE, ptr, len, bold );
  810.     if (mem_full) { mem_full = 0; return 1; }
  811.     return 0;
  812. }
  813.  
  814. static short check_TECut( hTE )
  815. eTeHandle hTE;
  816. { eTeCut( hTE );
  817.   if (mem_full) { mem_full = 0; return 1; }
  818.   return 0;
  819. }
  820.  
  821. static short check_TECopy( hTE )
  822. eTeHandle hTE;
  823. { eTeCopy( hTE );
  824.   if (mem_full) { mem_full = 0; return 1; }
  825.   return 0;
  826. }
  827.  
  828. static short check_TEPaste( hTE, bold )
  829. eTeHandle hTE;
  830. short bold;
  831. {     eTePaste( hTE, bold );
  832.     if (mem_full) { mem_full = 0; return 1; }
  833.     return 0;
  834. }
  835.  
  836. static short check_TEKey( c, hTE, bold, event )
  837. char c;
  838. eTeHandle hTE;
  839. short bold;
  840. EventRecord *event;
  841. {    eTeKey( hTE, c, (event->message & keyCodeMask) >> 8, event->modifiers, bold );
  842.     if (mem_full) { mem_full = 0; return 1; }
  843.     return 0;
  844. }
  845.  
  846. short getfullpath( vRefNum, dirID, fName, Path, MaxLength, warn )
  847. short vRefNum;
  848. long dirID;
  849. Str255 fName;
  850. char *Path;
  851. short MaxLength;
  852. short warn;
  853. {
  854.   char *p, *q;
  855.   long len;
  856.   CInfoPBRec block;
  857.   Str255 directoryName;
  858.  
  859.   p = &Path[MaxLength];
  860.   *--p = '\0';
  861.  
  862.   len = (unsigned char)fName[0];
  863.   p -= len;
  864.   if (p < Path) goto too_long;
  865.   BlockMove( &fName[1], p, len );
  866.  
  867.   block.dirInfo.ioNamePtr = directoryName;
  868.   block.dirInfo.ioDrParID = dirID;
  869.  
  870.   do
  871.   { block.dirInfo.ioVRefNum = vRefNum;
  872.     block.dirInfo.ioFDirIndex = -1;
  873.     block.dirInfo.ioDrDirID = block.dirInfo.ioDrParID;
  874.  
  875.     if (PBGetCatInfo( &block, FALSE ) != noErr) return 0;
  876.     *--p = ':';
  877.     len = (unsigned char)directoryName[0];
  878.     p -= len;
  879.     if (p < Path) goto too_long;
  880.     BlockMove( &directoryName[1], p, len );
  881.   } while ( block.dirInfo.ioDrDirID != fsRtDirID );
  882.  
  883.   q = Path;
  884.   while (*p != '\0') *q++ = *p++;
  885.   *q = '\0';
  886.  
  887.   return 1;
  888.  
  889.   too_long:
  890.   if (warn) path_too_long_err( fName );
  891.   return 0;
  892. }
  893.  
  894. /* 3Jul92  e  so I could get rid of MacTraps2 */
  895. #ifdef use_MacTraps2
  896. short getfullpathfromwd( wdRefNum, fName, Path, MaxLength, warn )
  897. long wdRefNum;
  898. Str255 fName;
  899. char *Path;
  900. short MaxLength;
  901. short warn;
  902. {
  903.   short vRefNum;
  904.   long dirID, procID;
  905.  
  906.   if (GetWDInfo( wdRefNum, &vRefNum, &dirID, &procID ) != noErr) return 0;
  907.  
  908.   return getfullpath( vRefNum, dirID, fName, Path, MaxLength, warn );
  909. }
  910. #else
  911. /* pascal OSErr GetWDInfo(short wdRefNum,short *vRefNum,long *dirID,long *procID) */
  912. short getfullpathfromwd( wdRefNum, fName, Path, MaxLength, warn )
  913. long wdRefNum;
  914. Str255 fName;
  915. char *Path;
  916. short MaxLength;
  917. short warn;
  918. {
  919.   WDPBRec myBlock;
  920.  
  921.   myBlock.ioNamePtr = nil;
  922.   myBlock.ioVRefNum = wdRefNum;
  923.   myBlock.ioWDIndex = 0;
  924.   myBlock.ioWDProcID = 0;
  925.   PBGetWDInfo(&myBlock,false);
  926.  
  927.   if ( myBlock.ioResult != noErr ) return 0;
  928.  
  929.   return getfullpath( myBlock.ioWDVRefNum, myBlock.ioWDDirID, fName, Path, MaxLength, warn );
  930. }
  931. #endif
  932.  
  933. short getfullpathfromcurrentvolume( fName, Path, MaxLength, warn )
  934. Str255 fName;
  935. char *Path;
  936. short MaxLength;
  937. short warn;
  938. { return getfullpathfromwd( (long)current_volume, fName, Path, MaxLength, warn );
  939. }
  940.  
  941. static Point SFGwhere = { 90, 82 };
  942. static Point SFPwhere = { 106, 104 };
  943.  
  944. short get_file( prompt, nbtypes, ftypes, path, maxlength )
  945. Str255 prompt;
  946. short nbtypes;
  947. char *ftypes;
  948. char *path;
  949. short maxlength;
  950. {
  951.   SFReply reply;
  952.  
  953.   if (nbtypes == 0) nbtypes = -1;
  954.  
  955.   eTePutScrap();    /* 10Jan93  e */
  956.   SFGetFile( SFGwhere, prompt, 0L, nbtypes, (SFTypeList *)ftypes, 0L, &reply );
  957.   eTeGetScrap();    /* 10Jan93  e */
  958.   if (!reply.good) return 0;
  959.  
  960.   current_volume = reply.vRefNum;
  961.   return getfullpathfromwd( (long)current_volume, (StringPtr)reply.fName, path, maxlength, 1 );
  962. }
  963.  
  964. short put_file( prompt, deflt, path, maxlength )
  965. Str255 prompt;
  966. Str255 deflt;
  967. char *path;
  968. short maxlength;
  969. {
  970.   SFReply reply;
  971.  
  972.   eTePutScrap();    /* 10Jan93  e */
  973.   SFPutFile( SFPwhere, prompt, deflt, 0L, &reply );
  974.   eTeGetScrap();    /* 10Jan93  e */
  975.   if (!reply.good) return 0;
  976.  
  977.   current_volume = reply.vRefNum;
  978.   return getfullpathfromwd( (long)current_volume, (StringPtr)reply.fName, path, maxlength, 1 );
  979. }
  980.  
  981. static short wptr_to_id( w )
  982. WindowPtr w;
  983. { short id;
  984.   for (id=0; id<MAX_NB_WINDOWS; id++)
  985.     if ((wind_table[id].in_use) && (wind_table[id].wptr == (WindowPtr )w)) return id;
  986.   return -1;
  987. }
  988.  
  989. static void setup_view( id )
  990. short id;
  991. { WindowPtr w = wind_table[id].wptr;
  992.   TeHANDLE hTE = wind_table[id].hTE;
  993.   Rect view = w->portRect;
  994.   /*
  995.   view.right -= SBarWidth;
  996.   view.bottom -= SBarWidth;
  997.   InsetRect(&view, Border, Border);                /*  21Jul92  e  */
  998.   view.top    += Border;
  999.   view.left   += Border;
  1000.   view.bottom -= SBarWidth;
  1001.   view.right  -= SBarWidth;
  1002.   eTeNewView( hTE, &view );
  1003. }
  1004.  
  1005. /* 10Jan93  e -- added display of caret position */
  1006. #if 0
  1007. static void content( short id, EventRecord *event )
  1008. { WindowPtr w = wind_table[id].wptr;
  1009.   eTeHandle hTE = wind_table[id].hTE;
  1010.   short cntlCode;
  1011.   ControlHandle theControl;
  1012.  
  1013.   SetPort( w );
  1014.   ClipRect( &w->portRect );
  1015.   GlobalToLocal( &event->where );
  1016.   if ((cntlCode = FindControl( event->where, w, &theControl )) == 0 )
  1017.   { if (PtInRect( event->where, &(**hTE).viewRect ))
  1018.       eTeClick( hTE, event->where, event->modifiers, event->when );
  1019.   }
  1020.   else if (cntlCode == inThumb)
  1021.   { cntlCode = GetCtlValue( theControl );
  1022.     TrackControl( theControl, event->where, 0L );
  1023.     if ( ( cntlCode = GetCtlValue( theControl ) - cntlCode ) != 0 )
  1024.         if( (**theControl).contrlRect.left < (**theControl).contrlRect.top ) /* horizontal? */
  1025.             eTeScroll( hTE, cntlCode, 0, TRUE );
  1026.         else
  1027.             eTeScroll( hTE, 0, cntlCode, TRUE );
  1028.   }
  1029.   else
  1030.     TrackControl( theControl, event->where, (ProcPtr )-1L );
  1031. }
  1032. #else
  1033. static void really_inval_msgrect( short w )
  1034. { GrafPtr port = wind_table[w].wptr;
  1035.   Rect r = port->portRect;
  1036.   r.right -= (( r.right - r.left ) >> 1 ) + SBarWidth + 1;
  1037.   r.top = r.bottom - SBarWidth + 1;
  1038.   SetPort( port );
  1039.   InvalRect( &r );
  1040. }
  1041. static void inval_msgrect( short w )
  1042. { if ( showPosnP ) wind_table[w].needs_inval_ticks = TickCount();
  1043. }
  1044. static void content( short id, EventRecord *event )
  1045. { WindowPtr w = wind_table[id].wptr;
  1046.   eTeHandle hTE = wind_table[id].hTE;
  1047.   short cntlCode;
  1048.   ControlHandle theControl;
  1049.   ChPos oldCaret;
  1050.  
  1051.   SetPort( w );
  1052.   ClipRect( &w->portRect );
  1053.   GlobalToLocal( &event->where );
  1054.   if ((cntlCode = FindControl( event->where, w, &theControl )) == 0 )
  1055.   { if (PtInRect( event->where, &(**hTE).viewRect ))
  1056.     { oldCaret = (**hTE).caretChPos;
  1057.       eTeClick( hTE, event->where, event->modifiers, event->when );
  1058.       if ( *(long *)&oldCaret != *(long *)&(**hTE).caretChPos ) inval_msgrect( id );
  1059.     }
  1060.   }
  1061.   else if (cntlCode == inThumb)
  1062.   { cntlCode = GetCtlValue( theControl );
  1063.     TrackControl( theControl, event->where, 0L );
  1064.     if ( ( cntlCode = GetCtlValue( theControl ) - cntlCode ) != 0 )
  1065.         if( (**theControl).contrlRect.left < (**theControl).contrlRect.top ) /* horizontal? */
  1066.             eTeScroll( hTE, cntlCode, 0, TRUE );
  1067.         else
  1068.             eTeScroll( hTE, 0, cntlCode, TRUE );
  1069.   }
  1070.   else
  1071.     TrackControl( theControl, event->where, (ProcPtr )-1L );
  1072. }
  1073. #endif
  1074. /* 10Jan93  e -- added display of caret position */
  1075. #if 0
  1076. static void update_window( short w )
  1077. { GrafPtr port = wind_table[w].wptr;
  1078.   Rect r = port->portRect;
  1079. #ifdef USE_eTe_debug
  1080.   Str255 tStr;
  1081. #endif
  1082.   r.right -= (( r.right - r.left ) >> 1 ) + SBarWidth + 1;
  1083.   r.top = r.bottom - SBarWidth;
  1084.   SetPort( port );
  1085.   ClipRect( &port->portRect );    /* added for eTe  16Apr92  e  */
  1086.   BeginUpdate( port );
  1087.   EraseRect( &port->portRect );
  1088.   DrawControls( port );
  1089.   DrawGrowIcon( port );
  1090.   EraseRect( &r );
  1091.   MoveTo( r.left, r.top );
  1092.   LineTo( r.right, r.top );
  1093. #ifdef USE_eTe_debug
  1094.   NumToString( eTeTextLength( wind_table[w].hTE ), tStr);
  1095.   MoveTo( r.left + 4, r.bottom - 4 );
  1096.   ClipRect( &r );
  1097.   DrawString( (ConstStr255Param )tStr );
  1098. #endif
  1099.   eTeUpdate( wind_table[w].hTE );
  1100.   EndUpdate( port );
  1101. }
  1102. #else
  1103. static void update_window( short w )
  1104. { GrafPtr port = wind_table[w].wptr;
  1105.   Rect r = port->portRect;
  1106.   Str255 tStr;
  1107.   eTeHandle hTE;
  1108.   r.right -= (( r.right - r.left ) >> 1 ) + SBarWidth + 1;
  1109.   r.top = r.bottom - SBarWidth;
  1110.   SetPort( port );
  1111.   ClipRect( &port->portRect );    /* added for eTe  16Apr92  e  */
  1112.   BeginUpdate( port );
  1113.   EraseRect( &port->portRect );
  1114.   DrawControls( port );
  1115.   DrawGrowIcon( port );
  1116.   EraseRect( &r );
  1117.   MoveTo( r.left, r.top );
  1118.   LineTo( r.right, r.top );
  1119. #ifdef USE_eTe_debug
  1120.   NumToString( eTeTextLength( wind_table[w].hTE ), tStr);
  1121.   MoveTo( r.left + 4, r.bottom - 4 );
  1122.   ClipRect( &r );
  1123.   DrawString( (ConstStr255Param )tStr );
  1124. #else
  1125.   if ( showPosnP )
  1126.   { hTE = wind_table[w].hTE;
  1127.     MoveTo( r.left + 4, r.bottom - 4 );
  1128.     ClipRect( &r );
  1129.     NumToString( (long )(**hTE).caretChPos.v, tStr);
  1130.     DrawString( (ConstStr255Param )tStr );
  1131.     DrawString( "\p:" );
  1132.     NumToString( (long )(**hTE).caretChPos.h, tStr);
  1133.     DrawString( (ConstStr255Param )tStr );
  1134.   }
  1135. #endif
  1136.   eTeUpdate( wind_table[w].hTE );
  1137.   EndUpdate( port );
  1138. }
  1139. #endif
  1140.  
  1141. static void grow_window( id, p )
  1142. short id;
  1143. Point p;
  1144. { WindowPtr w = wind_table[id].wptr;
  1145.   long result;
  1146.   short oScroll;
  1147.   Rect r, oView;
  1148.   
  1149.   SetPort( w );
  1150.  
  1151.   /* 16Sep92  e  increase min size for H scroll bar
  1152.   SetRect(&r, 80, 80, screenBits.bounds.right, screenBits.bounds.bottom); */
  1153.   /* 13Oct92  e  per: bernard@sigi.cs.colorado.edu
  1154.   SetRect(&r, 150, 80, screenBits.bounds.right, screenBits.bounds.bottom); */
  1155.   r = (**GetGrayRgn()).rgnBBox;
  1156.   r.top = 80;
  1157.   r.left = 150;
  1158.   /*  13Oct92  e  */
  1159.   result = GrowWindow( w, p, &r );
  1160.   if (result == 0) return;
  1161.   SizeWindow( w, LoWord(result), HiWord(result), 1);
  1162.  
  1163.   InvalRect(&w->portRect);
  1164.   setup_view( id );
  1165.   HideControl( wind_table[id].vscroll );
  1166.   MoveControl( wind_table[id].vscroll, w->portRect.right - SBarWidth, w->portRect.top-1);
  1167.   SizeControl( wind_table[id].vscroll, SBarWidth+1, w->portRect.bottom - w->portRect.top-(SBarWidth-2));
  1168.   HideControl( wind_table[id].hscroll );
  1169.   MoveControl( wind_table[id].hscroll,
  1170.                   w->portRect.right-((w->portRect.right-w->portRect.left)>>1),
  1171.                   w->portRect.bottom - SBarWidth);
  1172.   SizeControl( wind_table[id].hscroll,
  1173.                   ((w->portRect.right-w->portRect.left)>>1)-(SBarWidth-1),
  1174.                   SBarWidth+1);
  1175.   ShowControl( wind_table[id].hscroll );
  1176.   ValidRect(&(*wind_table[id].hscroll)->contrlRect );
  1177.   ShowControl( wind_table[id].vscroll );
  1178.   ValidRect(&(*wind_table[id].vscroll)->contrlRect );
  1179.   update_window( id );
  1180.   /* dunno (sometimes appropriate, sometimes not)... eTeShowCaret( wind_table[id].hTE ); */
  1181. }
  1182.  
  1183. static void put_input( id, ptr, len, cr, flush, freshline )
  1184. short id;
  1185. char *ptr;
  1186. short len;
  1187. short cr, flush, freshline;
  1188. { if (wind_table[id].in_use)
  1189.   { long len1;
  1190.     register long len2 = (wind_table[id].len - wind_table[id].pos);
  1191.     register char *buf, *p1, *p2;
  1192.     if ((len2 < 0) || flush) len2 = 0;
  1193.     len1 = ((cr)?1:0) + len2 + (long)len;
  1194.     buf = NewPtr( len1 );
  1195.     if (buf == NULL) { SysBeep(10); return; }
  1196.     p1 = buf;
  1197.     p2 = wind_table[id].buf + wind_table[id].pos;
  1198.     while (len2 > 0) { *p1++ = *p2++; len2--; }
  1199.     p2 = ptr;
  1200.     while (len > 0) { *p1++ = *p2++; len--; }
  1201.     if (cr) *p1++ = '\r';
  1202.     if (wind_table[id].buf != NULL) DisposPtr( wind_table[id].buf );
  1203.     wind_table[id].buf = buf;
  1204.     wind_table[id].pos = 0;
  1205.     wind_table[id].len = len1;
  1206.     if (freshline)
  1207.     { eTeHandle hTE = wind_table[id].hTE;
  1208.       if ( (**hTE).caretChPos.h > 0 )
  1209.         check_TEInsert( "\r", 1L, hTE, 0 );
  1210.       (**hTE).writeChPos = (**hTE).caretChPos; /*  9Jul92  e  */
  1211.       eTeShowCaret( hTE );
  1212.     }
  1213.   }
  1214. }
  1215.  
  1216. static void handle_interrupt()
  1217. { interrupted = 1;
  1218.   /* FlushEvents(keyDownMask,0); */
  1219.   /* raise(SIGINT); */
  1220.   /* errno = EINTR; */
  1221. }
  1222.  
  1223. static short open_file( filename, for_output, txt, io )
  1224. Str255 filename;
  1225. short for_output;
  1226. short txt;
  1227. short *io;
  1228. { ioParam pb;
  1229.   fileParam fp;
  1230.   short refnum;
  1231.   short len = (unsigned char)filename[0];
  1232.   short file_existed = 1;
  1233.  
  1234.   pb.ioNamePtr = filename;
  1235.   pb.ioVRefNum = current_volume;
  1236.   pb.ioVersNum = 0;
  1237.   pb.ioPermssn = ((for_output) ? fsRdWrPerm : fsRdPerm);
  1238.   pb.ioMisc = 0;
  1239.  
  1240.   if (for_output)
  1241.   { asm
  1242.     { lea    pb,a0
  1243.       _PBCreate
  1244.     }
  1245.     file_existed = (pb.ioResult == dupFNErr);
  1246.     if ((pb.ioResult != noErr) && !file_existed)
  1247.     { *io = pb.ioResult;  return -1; }
  1248.   }
  1249.   
  1250.   asm
  1251.   { lea    pb,a0
  1252.     _PBOpen
  1253.   }
  1254.   if (pb.ioResult != noErr)
  1255.   { if (for_output)
  1256.       asm
  1257.       { lea    pb,a0
  1258.         _PBDelete
  1259.       }
  1260.     *io = pb.ioResult;
  1261.     return -1;
  1262.   }
  1263.   refnum = pb.ioRefNum;
  1264.   
  1265.   if (!for_output) { *io = noErr; return refnum; }
  1266.  
  1267.   asm
  1268.   { lea    pb,a0
  1269.     _PBSetEOF
  1270.   }
  1271.  
  1272.   if (!file_existed)
  1273.   { fp.ioNamePtr = filename;
  1274.     fp.ioVRefNum = current_volume;
  1275.     fp.ioFVersNum = 0;
  1276.     fp.ioFDirIndex = 0;
  1277.     asm
  1278.     { lea    fp,a0
  1279.       _PBGetFInfo
  1280.       bmi.s  @1
  1281.     }
  1282.     if (txt)
  1283.       fp.ioFlFndrInfo.fdType = 'TEXT';
  1284.     else
  1285.       fp.ioFlFndrInfo.fdType = 'DATA';
  1286.     fp.ioFlFndrInfo.fdCreator = 'NJML';
  1287.     asm
  1288.     { lea    fp,a0
  1289.       _PBSetFInfo
  1290.       @1
  1291.     }
  1292.   }
  1293.  
  1294.   *io = noErr;
  1295.   return refnum;
  1296. }
  1297.  
  1298. static short close_file( refnum, io )
  1299. short refnum;
  1300. short *io;
  1301. { *io = FSClose( refnum );
  1302.   return (*io != noErr);
  1303. }
  1304.  
  1305. static short read_file( id, line, chr )
  1306. short id;
  1307. long line;
  1308. long chr;
  1309. { TeHANDLE hTE = wind_table[id].hTE;
  1310.   short refnum;
  1311.   short io, io2;
  1312.   long pos = 0;
  1313.   short result;
  1314.   Rect r;
  1315.   short beep = 0;
  1316.   short text = 0;
  1317.   long size, count;
  1318.   ChPos chPos;
  1319.   Handle hData;
  1320.   
  1321.   if ( line > 32768 )
  1322.   { te_limit_err();
  1323.     return 0;
  1324.   }
  1325.   chPos.v = (line==0) ? 0 : line-1;
  1326.   chPos.h = (line==0) ? 0 : chr;
  1327.  
  1328.   SelectWindow( wind_table[id].wptr );
  1329.  
  1330.   if (wind_table[id].dirty)
  1331.     if (!discard_changes( id )) return 0;
  1332.  
  1333.   refnum = open_file( wind_table[id].filename, 0, 1, &io );
  1334.   if (refnum == -1)
  1335.   { io_err( io );
  1336.     return 0;
  1337.   }
  1338.  
  1339.   eTeSetTextPtr( hTE, (Ptr )&text, 1L );
  1340.   io = GetEOF(refnum, &size);
  1341.   if( io == noErr )    {
  1342.     if( hData = NewHandle( size + 1 ) )
  1343.     {    HLock( hData );
  1344.         count = size;
  1345.         io = FSRead( refnum, &count, *hData );
  1346.         HUnlock( hData );
  1347.         if( ( io != noErr ) || ( count != size ) )
  1348.         {    DisposHandle( hData );
  1349.             if ( io == noErr ) io = ioErr;
  1350.             /* io_err( io ); will happen */
  1351.             /* added these next lines 7Jul92  e */
  1352.             mem_full = 0;
  1353.               eTeSetTextPtr( hTE, (Ptr )&text, 1L );
  1354.         }
  1355.         else
  1356.         {    ((char *)*hData)[size] = '\0';
  1357.             io = eTeSetTextHandleDetabify( hTE, hData, prefTabs );
  1358.             if ( io == noErr )
  1359.             {   count = eTeChPosToOffset( hTE, chPos );
  1360.                 if ( count > 0 )
  1361.                     eTeSetSelect( hTE, count-1, count );
  1362.                 else
  1363.                     eTeSetSelect( hTE, count, count );
  1364.                 eTeShowCaret( hTE );
  1365.             }
  1366.             else
  1367.             {    DisposHandle( hData );
  1368.                 /* io_err( io ); will happen */
  1369.                 /* added these next lines 7Jul92  e */
  1370.                 mem_full = 0;
  1371.                   eTeSetTextPtr( hTE, (Ptr )&text, 1L );
  1372.             }
  1373.           }
  1374.       }
  1375.       else
  1376.       { mem_full = 0; io = mFulErr; }     /* mem_full = 0; added  7Jul92  e */
  1377.   }
  1378.  
  1379.   if (close_file( refnum, &io2 ) || ((io != eofErr) && (io != noErr)))
  1380.   { if ((io != eofErr) && (io != noErr)) io_err( io ); else io_err( io2 );
  1381.       eSmudgeWindow( id );
  1382.       return 0;
  1383.   }
  1384.   if (io != noErr)
  1385.       eSmudgeWindow( id );
  1386.   else
  1387.       eUnSmudgeWindow( id, hTE );
  1388.   return (io == noErr);
  1389. }
  1390.  
  1391. static void write_file( id )
  1392. short id;
  1393. { TeHANDLE hTE = wind_table[id].hTE;
  1394.   short refnum;
  1395.   short io, io2;
  1396.   long count;
  1397.  
  1398.   refnum = open_file( wind_table[id].filename, 1, 1, &io );
  1399.   if (refnum == -1)
  1400.   { io_err( io );
  1401.     return;
  1402.   }
  1403.  
  1404.   count = eTeTextLength( hTE );
  1405.   io = FSWrite( refnum, &count, *((**hTE).hText) );
  1406.  
  1407.   if (close_file( refnum, &io2 ) || (io != noErr))
  1408.   { if (io != noErr) io_err( io ); else io_err( io2 );
  1409.     return;
  1410.   }
  1411.  
  1412.   eUnSmudgeWindow( id, hTE );
  1413. }
  1414.  
  1415. short edit( name, line, chr )
  1416. char *name;
  1417. long line;
  1418. long chr;
  1419. { short id;
  1420.   Str255 pname;
  1421.   c_to_p( name, pname );
  1422.   if (pname[0] != '\0')
  1423.   { for (id=0; id<MAX_NB_WINDOWS; id++)
  1424.       if (wind_table[id].in_use && wind_table[id].is_file &&
  1425.           (compare_p_to_p( wind_table[id].filename, pname ) == 0)) break;
  1426.   }
  1427.   else
  1428.     id = MAX_NB_WINDOWS;
  1429.  
  1430.   if (id == MAX_NB_WINDOWS) id = wind_open( name, /* 27Jan93 e -- TRUE */ FALSE, TRUE, FALSE );
  1431.   if (id < 0)
  1432.     wind_err();
  1433.   else
  1434.   { wind_table[id].is_file = 1;
  1435.     p_to_p( pname, wind_table[id].filename );
  1436.     supress_mem_full_dialog = 1;        /* 27Jan93  e  */
  1437.     if ( read_file( id, line, chr ) )
  1438.         select_and_show( wind_table[id].wptr );
  1439.     else
  1440.         wind_close( id );
  1441.     supress_mem_full_dialog = 0;        /* 27Jan93  e  */
  1442.   }
  1443.   return id;
  1444. }
  1445.  
  1446. void save_as( id, path )
  1447. short id;
  1448. char *path;
  1449. { Str255 ppath;
  1450.   short i;
  1451.   c_to_p( path, ppath );
  1452.   for (i=0; i<MAX_NB_WINDOWS; i++)
  1453.     if (wind_table[i].in_use && wind_table[i].is_file &&
  1454.         (compare_p_to_p( wind_table[i].filename, ppath ) == 0))
  1455.     { already_open_err( ppath );
  1456.       return;
  1457.     }
  1458.   p_to_p( ppath, wind_table[id].filename );
  1459.   if (wind_table[id].is_file) SetWTitle( wind_table[id].wptr, ppath );
  1460.   if ( id != interaction_id ) /* 28Jan93  e  */
  1461.   { delWindMenuItem( id );
  1462.     addWindMenuItem( id );
  1463.   }
  1464.   write_file( id );
  1465. }
  1466.  
  1467. static void wind_quit()
  1468. { short id;
  1469.   for (id=MAX_NB_WINDOWS-1; id>=0; id--)
  1470.   { if (wind_table[id].in_use && wind_table[id].is_file && wind_table[id].dirty)
  1471.     { if (!discard_changes( id )) return;
  1472.       wind_close( id );
  1473.     }
  1474.   }
  1475.   abnormal_exit = 0;
  1476.   /* os_quit();    29Dec92  e  */
  1477.   gDoQuit = 1;    /* 29Dec92  e  */
  1478. }
  1479.  
  1480. static void handle_close( id )
  1481. short id;
  1482. { if (wind_table[id].is_file)
  1483.   { if ((wind_table[id].dirty) && (!discard_changes( id ))) return;
  1484.     wind_close( id );
  1485.   }
  1486. }
  1487.  
  1488. static char upcase( char c )
  1489. { if( c >= 'a' &&  c <= 'z' ) return c - 0x20;
  1490.   else return c;
  1491. }
  1492. /* 08Jan93  e  -- changed to return Boolean; added test for empty find string */
  1493. Boolean find_next( id )
  1494. short id;
  1495. { TeHANDLE hTE = wind_table[id].hTE;
  1496.   char *txt = *((**hTE).hText);
  1497.   long pos = eTeChPosToOffset( hTE, (**hTE).selActive ? (**hTE).selEnd : (**hTE).caretChPos );
  1498.   register char *start = txt + pos - 1;
  1499.   register short len = (unsigned char)find_string[0];
  1500.   register char *end = txt + eTeTextLength( hTE ) - len;
  1501.   register short i;
  1502.   Boolean again = TRUE;
  1503.   Str255 ci_string;
  1504.   if ( len == 0 ) goto not_found;
  1505.   if( find_ci )
  1506.   { for (i=len; i>0; i--)
  1507.       ci_string[i] = upcase( find_string[i] );
  1508.     /* ci_string[0] = len; -- not used */
  1509.   }
  1510.   find_begin:
  1511.   while (start < end)
  1512.   { if( find_ci )
  1513.     { for (i=len; i>0; i--)
  1514.         if( upcase( start[i] ) != (char )ci_string[i] ) goto next_pos;
  1515.     }
  1516.     else
  1517.     { for (i=len; i>0; i--)
  1518.         if (start[i] != (char )find_string[i]) goto next_pos;
  1519.     }
  1520.     eTeSetSelect( hTE, (long)(start-txt+1), (long)(start-txt+1+len) );
  1521.     return 1;
  1522.     next_pos:
  1523.     start++;
  1524.   }
  1525.   if( find_wrap && again ) 
  1526.   { start = txt;
  1527.     end = start + pos - len;
  1528.     again = FALSE;
  1529.     goto find_begin;
  1530.   }
  1531. not_found:
  1532.   SysBeep(10);
  1533.   return 0;
  1534. }
  1535.  
  1536. void replace_next( id )
  1537. short id;
  1538. { TeHANDLE hTE = wind_table[id].hTE;
  1539.   if ( ! (**hTE).selActive )
  1540.     SysBeep(10);
  1541.   else
  1542.   { long len = (unsigned char)replace_string[0];
  1543.     check_TEInsert( ((char *)replace_string)+1, len, hTE, wind_table[id].bold_input );
  1544.     find_next( id );
  1545.     eTeShowCaret( hTE );
  1546.   }
  1547. }
  1548.  
  1549. /* 08Jan93  e  */
  1550. void replace_all( id )
  1551. short id;
  1552. { TeHANDLE hTE = wind_table[id].hTE;
  1553.   long len = (unsigned char)replace_string[0];
  1554.   
  1555.   if ( (**hTE).selActive )
  1556.   { long pos = eTeChPosToOffset( hTE, (**hTE).selStart );
  1557.     eTeSetSelect( hTE, pos, pos );
  1558.   }
  1559.   while ( find_next( id ) )
  1560.     check_TEInsert( ((char *)replace_string)+1, len, hTE, wind_table[id].bold_input );
  1561.   eTeShowCaret( hTE );
  1562. }
  1563.  
  1564. static void find_dialog( short id )
  1565. { DialogPtr dp;
  1566.   short i, s;
  1567.   Handle h;
  1568.   Rect r;
  1569.   eTePutScrap();                                          /*  13Oct92  e  */
  1570.   ParamText( "\pFind:", "\pReplace with:", "\p", "\p" );
  1571.   dp = GetNewDialog( find_dlogID, 0L, (WindowPtr)-1L );
  1572.   if (dp == NULL) return;
  1573.   GetDItem( dp, 3, &i, &h, &r );
  1574.   SetIText( h, find_string );
  1575.   GetDItem( dp, 5, &i, &h, &r );
  1576.   SetIText( h, replace_string );
  1577.   GetDItem( dp, 7, &i, &h, &r);
  1578.   SetCtlValue( h, find_wrap );
  1579.   GetDItem( dp, 8, &i, &h, &r);
  1580.   SetCtlValue( h, find_ci );
  1581.   SelIText( dp, 3, 0, find_string[0] );
  1582.   SetCursor( &arrow );
  1583.   do
  1584.   { ModalDialog( 0L, &s );
  1585.     switch( s )
  1586.     { case 1:
  1587.         GetDItem( dp, 3, &i, &h, &r );
  1588.         GetIText( h, find_string );
  1589.         GetDItem( dp, 5, &i, &h, &r );
  1590.         GetIText( h, replace_string );
  1591.         GetDItem( dp, 7, &i, &h, &r);
  1592.         find_wrap = GetCtlValue( h );
  1593.         GetDItem( dp, 8, &i, &h, &r);
  1594.         find_ci   = GetCtlValue( h );
  1595.         break;
  1596.       case 7:
  1597.       case 8:
  1598.         GetDItem( dp, s, &i, &h, &r );
  1599.         SetCtlValue( (ControlHandle )h, GetCtlValue( (ControlHandle )h ) ^ 1 );
  1600.         break;
  1601.     }
  1602.   } while( s != 1 && s != 2 );
  1603.   CloseDialog( dp );
  1604.   if( s == 1 ) find_next( id );
  1605.   eTeGetScrap();                                          /*  13Oct92  e  */
  1606. }
  1607.  
  1608. /* 25Sep92  e  added print menu items */
  1609.  
  1610. static void handle_pgsetup( short id )
  1611. { 
  1612.   TeHANDLE hTE = wind_table[id].hTE;
  1613.   SetCursor(&qd.arrow);
  1614.   PageSetupDialog( hTE );
  1615. }
  1616.  
  1617. /* 02Oct92  e  added iPrAbort check */
  1618.  
  1619. static void handle_print( short id )
  1620. { 
  1621.   OSErr err;
  1622.   TeHANDLE hTE = wind_table[id].hTE;
  1623.   Str255 flnm;
  1624.   
  1625.   SetCursor(&qd.arrow);
  1626.   err = noErr;
  1627.   if ( ! (**hTE).hPrint )
  1628.     err = PageSetupDialog( hTE );
  1629.   if( ! err )
  1630.   {    pathstr_to_filename( wind_table[id].filename, flnm );
  1631.     err = eTePrint( hTE, true, true, flnm );
  1632.     eTePrint( nil, false, false, flnm );
  1633.   }
  1634.   if( err && err != userCanceledErr && err != iPrAbort ) io_err( err );
  1635. }
  1636.  
  1637. static short handle_menu( result, id )
  1638. long result;
  1639. short id;
  1640. { short theItem, theMenu, m, w;
  1641.   MenuHandle mh;
  1642.   WindowPeek wPtr;
  1643.   Str255 name;
  1644.  
  1645.   theItem = LoWord( result );
  1646.   theMenu = HiWord( result );
  1647.   if (theMenu == 0) return 1;
  1648.   mh = GetMHandle( theMenu );
  1649.   for (m=appleM; m<=windowsM; m++) if (menus[m] == mh) break;
  1650.   switch (m)
  1651.   { case appleM:
  1652.       if (theItem == 1)
  1653.       { eDoDialog(0);    /* about */
  1654.       }
  1655.       else if (theItem == 2)
  1656.         ;
  1657.       else
  1658.       { GetItem(menus[appleM], theItem, &name);
  1659.         OpenDeskAcc( &name );
  1660.       }
  1661.       break;
  1662.     case fileM: 
  1663.       switch (theItem)
  1664.       { case newCommand:
  1665.         { short w = wind_open( "Untitled", TRUE, TRUE, FALSE );
  1666.           if (w < 0)
  1667.             wind_err();
  1668.           else
  1669.             wind_table[w].is_file = 1;
  1670.           break;
  1671.         }
  1672.         case openCommand:
  1673.         { short i;
  1674.           for (i=0; i<MAX_NB_WINDOWS; i++) if (!wind_table[i].in_use) break;
  1675.           if (i == MAX_NB_WINDOWS)
  1676.             wind_err();
  1677.           else
  1678.           { char path[FILENAME_LEN];
  1679.             if (get_file( "\p", 1, "TEXT", path, FILENAME_LEN ))
  1680.               edit( path, 0L, 0L );
  1681.           }
  1682.           break;
  1683.         }
  1684.         case closeCommand:
  1685.           if (id >= 0)
  1686.             handle_close( id );
  1687.           break;
  1688.         case saveCommand:
  1689.           if (id >= 0)
  1690.             if (wind_table[id].is_file && (wind_table[id].filename[0] != '\0'))
  1691.             { write_file( id );
  1692.               break;
  1693.             }
  1694.         case saveasCommand:
  1695.           if (id >= 0)
  1696.           { char path[FILENAME_LEN];
  1697.             Str255 flnm;
  1698.             pathstr_to_filename( wind_table[id].filename, flnm );
  1699.             if (put_file( "\pSave as:", flnm, path, FILENAME_LEN ))
  1700.               save_as( id, path );
  1701.           }
  1702.           break;
  1703.         case revertCommand:
  1704.           if (id >= 0)
  1705.             read_file( id, 0L, 0L );
  1706.           break;
  1707.         /* 25Sep92  e  added print menu items */
  1708.         case pgsetupCommand:
  1709.           if (id >= 0)
  1710.             handle_pgsetup( id );
  1711.           break;
  1712.         case printCommand:
  1713.           if (id >= 0)
  1714.             handle_print( id );
  1715.           break;
  1716.         case quitCommand:
  1717.           wind_quit();
  1718.           if (gDoQuit) os_quit(); /* 29Dec92  e  */
  1719.           break;
  1720.       }
  1721.       break;
  1722.     /* 10Jan93  e  -- separated out Search menu */
  1723.     case editM: 
  1724.       if (id < 0)
  1725.         SystemEdit(theItem-1);
  1726.       else
  1727.       { TeHANDLE hTE = wind_table[id].hTE;
  1728.         switch (theItem)
  1729.         { case undoCommand:
  1730.             eTeUndo( hTE );
  1731.             eMaybeSmudgeWindow( id, hTE );
  1732.             break;
  1733.           case cutCommand:
  1734.             check_TECut( hTE );
  1735.             eMaybeSmudgeWindow( id, hTE );
  1736.             break;
  1737.           case copyCommand:
  1738.             check_TECopy( hTE );
  1739.             break;
  1740.           case pasteCommand:
  1741.             check_TEPaste( hTE, wind_table[id].bold_input );
  1742.             eMaybeSmudgeWindow( id, hTE );
  1743.             break;
  1744.           case clearCommand:
  1745.             eTeDelete( hTE );
  1746.             eMaybeSmudgeWindow( id, hTE );
  1747.             break;
  1748.           case selAllCommand:
  1749.             eTeSetSelect( hTE, 0, eTeTextLength( hTE ));
  1750.             break;
  1751.           case stylesCommand:
  1752.             eStyleDlg( hTE );
  1753.               break;
  1754.           case showPosnCommand:    /* 10Jan93  e  */
  1755.               showPosnP ^= 1;
  1756.             CheckItem( menus[editM], showPosnCommand, showPosnP );
  1757.             for (w=0; w<MAX_NB_WINDOWS; w++)
  1758.                 if (wind_table[w].in_use) really_inval_msgrect( w );
  1759.               break;
  1760.           default: ;
  1761.         }
  1762.         eTeShowCaret( hTE );
  1763.       }
  1764.       break;
  1765.     case findM:
  1766.       if (id >= 0)
  1767.       { TeHANDLE hTE = wind_table[id].hTE;
  1768.         switch (theItem)
  1769.         { case findCommand:
  1770.             find_dialog( id );
  1771.             break;
  1772.           case againCommand:
  1773.             find_next( id );
  1774.             break;
  1775.           case replaceCommand:
  1776.             replace_next( id );
  1777.             eMaybeSmudgeWindow( id, hTE );
  1778.             break;
  1779.           case fEnterCommand:
  1780.           { long sel_sta, sel_end, sel_len = 0;
  1781.             if( (**hTE).selActive ) {
  1782.               sel_sta = eTeChPosToOffset( hTE, (**hTE).selStart );
  1783.               sel_end = eTeChPosToOffset( hTE, (**hTE).selEnd );
  1784.               sel_len = sel_end - sel_sta;
  1785.             }
  1786.             if (sel_len > 0)
  1787.             { if( sel_len > 255 ) sel_len = 255;
  1788.               buf_to_p( (unsigned short)sel_len, *((**hTE).hText) + sel_sta, find_string );
  1789.             }
  1790.             else
  1791.               SysBeep( 1 );
  1792.             break;
  1793.           }
  1794.           case replaceAllCommand:    /* 08Jan93  e  */
  1795.             replace_all( id );
  1796.             eMaybeSmudgeWindow( id, hTE );
  1797.             break;
  1798.         }
  1799.         eTeShowCaret( hTE );
  1800.       }
  1801.       break;
  1802.     case commandM: 
  1803.       switch (theItem)
  1804.       { case interruptCommand:
  1805.           HiliteMenu(0);
  1806.           handle_interrupt();
  1807.           return 0;
  1808.         case helpCommand:
  1809.           eDoDialog(1);    /* add help stuff */
  1810.           break;
  1811.         default:
  1812.           break;
  1813.         }
  1814.       break;
  1815.     case windowsM:
  1816.       switch(theItem)
  1817.       { case 1:
  1818.           select_and_show( wind_table[interaction_id].wptr );
  1819.           break;
  1820.         case 2: /* blank line */
  1821.           break;
  1822.         default:
  1823.           theItem -= fustItem;
  1824.           if(theItem < qWindItems)
  1825.             SelectWindow( wind_table[itemtowindid[theItem]].wptr );
  1826.           break;
  1827.       }
  1828.       break;
  1829.    }
  1830.   HiliteMenu(0);
  1831.   return 1;
  1832. }
  1833.  
  1834. static short do_tasks()
  1835. { short w;
  1836.   register short i;
  1837.   short men;
  1838.   EventRecord event;
  1839.   Rect r;
  1840.   RgnHandle rgn;
  1841.   long ticks = Ticks;
  1842.  
  1843.   for (i=0; i<MAX_NB_WINDOWS; i++)
  1844.     if (wind_table[i].in_use)
  1845.     { if (wind_table[i].out_len > 0)
  1846.       { HLock( wind_table[i].out_buf );
  1847.         check_TEWrite( *wind_table[i].out_buf, (long)wind_table[i].out_len, wind_table[i].hTE, 0 );
  1848.         HUnlock( wind_table[i].out_buf );
  1849.         wind_table[i].out_len = 0;
  1850.       }
  1851.       /* 10Jan93  e -- added display of caret position */
  1852.       if ( wind_table[i].needs_inval_ticks != 0
  1853.            && ( wind_table[i].needs_inval_ticks + 15 ) < ticks )
  1854.       { really_inval_msgrect( i );
  1855.         wind_table[i].needs_inval_ticks = 0;
  1856.       }
  1857.     }
  1858.   w = wptr_to_id( FrontWindow() );
  1859.   if ( (!gInBackground) && (w >= 0) )
  1860.   { Point pt;
  1861.     Cursor *curs;
  1862.     OSEventAvail(0L, &event); /* This returns a NULL event with the global mouse location */
  1863.     if( gCursRgnOK && PtInRgn( event.where, gCursorRgn ) )
  1864.     { /* punt... SetCursor( current_cursor ); */
  1865.     }
  1866.     else
  1867.     { SetPort( (GrafPtr)wind_table[w].wptr );
  1868.       r = (**wind_table[w].hTE).viewRect;
  1869.       LocalToGlobal((Point *)&(r.top));      /* topLeft  */
  1870.       LocalToGlobal((Point *)&(r.bottom));   /* botRight */
  1871.       if (PtInRect( event.where, &r ))
  1872.       { curs = &ibeam_cursor;
  1873.         RectRgn(gCursorRgn, &r);
  1874.       }
  1875.       else
  1876.       { curs = &arrow;
  1877.         SetRectRgn(gCursorRgn, -32768, -32768, 32766, 32766);
  1878.         rgn = NewRgn();
  1879.         RectRgn(rgn, &r);
  1880.         DiffRgn(gCursorRgn, rgn, gCursorRgn);
  1881.         DisposeRgn(rgn);
  1882.       }
  1883.       if (!gCursRgnOK || current_cursor != curs)
  1884.       { current_cursor = curs;
  1885.         SetCursor( current_cursor );
  1886.       }
  1887.       gCursRgnOK = true;
  1888.     }
  1889.     eTeIdle( wind_table[w].hTE );
  1890.     men = (wind_table[w].is_file && (wind_table[w].filename[0] != '\0')) ? 1 : 0;
  1891.   }
  1892.   else
  1893.   { SetRectRgn(gCursorRgn, -32768, -32768, 32766, 32766);
  1894.     gCursRgnOK = false;
  1895.     SetCursor(&qd.arrow);    /*  13Oct92  e  */
  1896.     men = 2;
  1897.   }
  1898.  
  1899.   if ( (!gInBackground) && (men != current_menus) )
  1900.   { current_menus = men;
  1901.     switch (men)
  1902.     { case 0:
  1903.       case 1:
  1904.         /*
  1905.         EnableItem( menus[fileM], newCommand );
  1906.         EnableItem( menus[fileM], openCommand );
  1907.         EnableItem( menus[fileM], closeCommand );
  1908.         */
  1909.         EnableItem( menus[fileM], saveCommand );
  1910.         EnableItem( menus[fileM], saveasCommand );
  1911.         if (men == 0)
  1912.           DisableItem( menus[fileM], revertCommand );
  1913.         else
  1914.           EnableItem( menus[fileM], revertCommand );
  1915.         /*
  1916.         EnableItem( menus[fileM], quitCommand );
  1917.         */
  1918.         EnableItem( menus[fileM], pgsetupCommand );
  1919.         EnableItem( menus[fileM], printCommand );
  1920.         EnableItem( menus[editM], selAllCommand );
  1921.         EnableItem( menus[editM], stylesCommand );
  1922.         EnableItem( menus[editM], showPosnCommand );
  1923.         /*
  1924.         EnableItem( menus[findM], findCommand );
  1925.         EnableItem( menus[findM], againCommand );
  1926.         EnableItem( menus[findM], replaceCommand );
  1927.         EnableItem( menus[findM], replaceAllCommand );
  1928.         EnableItem( menus[findM], fEnterCommand ); */
  1929.         EnableItem( menus[findM], 0 );
  1930.         /*
  1931.         EnableItem( menus[commandM], 0 );
  1932.         */
  1933.         DrawMenuBar();
  1934.         break;
  1935.       case 2:
  1936.         /*
  1937.         DisableItem( menus[fileM], newCommand );
  1938.         DisableItem( menus[fileM], openCommand );
  1939.         DisableItem( menus[fileM], closeCommand );
  1940.         */
  1941.         DisableItem( menus[fileM], saveCommand );
  1942.         DisableItem( menus[fileM], saveasCommand );
  1943.         DisableItem( menus[fileM], revertCommand );
  1944.         /*
  1945.         DisableItem( menus[fileM], quitCommand );
  1946.         */
  1947.         DisableItem( menus[fileM], pgsetupCommand );
  1948.         DisableItem( menus[fileM], printCommand );
  1949.         DisableItem( menus[editM], selAllCommand );
  1950.         DisableItem( menus[editM], stylesCommand );
  1951.         DisableItem( menus[editM], showPosnCommand );
  1952.         /*
  1953.         DisableItem( menus[findM], findCommand );
  1954.         DisableItem( menus[findM], againCommand );
  1955.         DisableItem( menus[findM], replaceCommand );
  1956.         DisableItem( menus[findM], replaceAllCommand );
  1957.         DisableItem( menus[findM], fEnterCommand ); */
  1958.         DisableItem( menus[findM], 0 );
  1959.         /*
  1960.         DisableItem( menus[commandM], 0 );
  1961.         */
  1962.         DrawMenuBar();
  1963.         break;
  1964.     }
  1965.   }
  1966.  
  1967.   if ( (!gInBackground) && (w>=0) )
  1968.   { register EvQElPtr q;
  1969.     for (q = (EvQElPtr)EventQueue.qHead; q != NULL; q = (EvQElPtr)q->qLink)
  1970.       if ((q->evtQWhat == keyDown) && ((char)q->evtQMessage == '.') &&
  1971.           (q->evtQModifiers & cmdKey))
  1972.       { while (GetNextEvent(keyDownMask+keyUpMask+autoKeyMask,&event) &&
  1973.                !((event.what == keyDown) && ((event.message & charCodeMask) == '.') &&
  1974.                  ((event.modifiers & cmdKey) != 0) )) ;
  1975.         handle_interrupt();
  1976.         return 0;
  1977.       }
  1978.   }
  1979.   return 1;
  1980. }
  1981.  
  1982. /* from MacDTS */
  1983. #define kDITop                    0x0050        /* kTopLeft - for positioning the Disk */
  1984. #define kDILeft                    0x0070        /*   Initialization dialogs. */
  1985.  
  1986. void handle_activate( WindowPtr wptr, Boolean activep )
  1987. { GrafPtr port;
  1988.   Rect r;
  1989.   short w = wptr_to_id( wptr );
  1990.   if( w >= 0 )
  1991.   { port = wind_table[w].wptr;
  1992.     r = port->portRect;
  1993.     r.left = r.right - (SBarWidth+1);
  1994.     SetPort( port );
  1995.     InvalRect( &r );
  1996.     r = port->portRect;
  1997.     r.top = r.bottom - (SBarWidth+1);
  1998.     InvalRect( &r );
  1999.     if ( activep )
  2000.     { eTeActivate( wind_table[w].hTE );
  2001.       ShowControl( wind_table[w].vscroll );
  2002.       ShowControl( wind_table[w].hscroll );
  2003.     }
  2004.     else
  2005.     { eTeDeactivate( wind_table[w].hTE );
  2006.       HideControl( wind_table[w].vscroll );
  2007.       HideControl( wind_table[w].hscroll );
  2008.     }
  2009.   }
  2010. }
  2011.  
  2012. static short handle_event( event )
  2013. EventRecord *event;
  2014. { register short i;
  2015.   short w;
  2016.   WindowPtr event_window;
  2017.  
  2018.   if (IsDialogEvent( event ))
  2019.   { DialogPtr dp;
  2020.     short item;
  2021.     DialogSelect( event, &dp, &item );
  2022.     return 1;
  2023.   }
  2024.  
  2025.   w = wptr_to_id( FrontWindow() );
  2026.   { switch (event->what)
  2027.     { case mouseDown:
  2028.         gCursRgnOK = false;
  2029.         switch (FindWindow(event->where,&event_window))
  2030.         { case inDesk: 
  2031.             SysBeep( 10 );
  2032.             break;
  2033.           case inGoAway:
  2034.             if ((w = wptr_to_id( event_window )) >= 0)
  2035.               if (TrackGoAway(event_window,event->where)) handle_close( w );
  2036.             break;
  2037.           case inMenuBar:
  2038.           { TeHANDLE hTE = NULL;
  2039.             if( w >= 0) hTE = wind_table[w].hTE;
  2040.             eTeEditMenuUpdate( hTE, menus[editM] );
  2041.             return handle_menu( MenuSelect(event->where), w );
  2042.           }
  2043.           case inSysWindow:
  2044.             SystemClick(event,event_window);
  2045.             break;
  2046.           case inDrag:
  2047.             if ((w = wptr_to_id( event_window )) >= 0)
  2048.               DragWindow(event_window,event->where,&screenBits.bounds);
  2049.             break;
  2050.           case inGrow:
  2051.             if ((w = wptr_to_id( event_window )) >= 0)
  2052.               grow_window( w, event->where );
  2053.             break;
  2054.           case inContent:
  2055.             if (event_window != FrontWindow())
  2056.               SelectWindow(event_window);
  2057.             else 
  2058.               if ((w = wptr_to_id( event_window )) >= 0)
  2059.                 content( w, event );
  2060.             break;
  2061.           default: ;
  2062.         }
  2063.         gLastMouseDown = *event;
  2064.         break;
  2065.       case mouseUp:
  2066.         gLastMouseUp = *event;
  2067.         break;
  2068.       case keyDown:
  2069.       case autoKey:
  2070.         { unsigned char c = event->message & charCodeMask;
  2071.           TeHANDLE hTE = (w>=0)?wind_table[w].hTE:NULL;
  2072.           if ((event->modifiers & cmdKey) != 0)
  2073.           { long res;
  2074.             if (c == '=') c = '+'; else if (c == '/') c = '?';
  2075.             if (hTE != NULL) eTeEditMenuUpdate( hTE, menus[editM] );
  2076.             res = MenuKey( c );
  2077.             if( HiWord( res ) != 0 )
  2078.                 return handle_menu( res, w );
  2079.             if( (hTE != NULL) && (c >= 0) && (c <= 31) )
  2080.             {    check_TEKey( c, hTE, 0, event );
  2081.                 inval_msgrect( w ); /* 10Jan93  e -- added display of caret position */
  2082.             }
  2083.             break;
  2084.           }
  2085.           if (hTE == NULL) break;
  2086.           /*
  2087.           if( ( event->modifiers & controlKey ) != 0 )
  2088.           { eEditCommand( hTE, c, event->modifiers, wind_table[w].bold_input );
  2089.               eMaybeSmudgeWindow( w, hTE );
  2090.               inval_msgrect( w );
  2091.           }
  2092.           */
  2093.           else if( ( c == 127 /* del fwd */ )  || ( c <= 31 ) )
  2094.           { if( ( c == 3 /*enter*/ ) || (( c == '\r' /*cr*/ ) && ((event->modifiers & optionKey) != 0 )))
  2095.             { short id = (wind_table[w].is_file) ? interaction_id : w;
  2096.               long sel_sta;
  2097.               long sel_end;
  2098.               long sel_len;
  2099.               if( (**hTE).selActive ) {
  2100.                   sel_sta = eTeChPosToOffset( hTE, (**hTE).selStart );
  2101.                   sel_end = eTeChPosToOffset( hTE, (**hTE).selEnd );
  2102.               }
  2103.               else
  2104.               { extern void eTeGetRun( eRec **hE, long *sta, long *end );
  2105.                 if ( w == interaction_id )
  2106.                   eTeGetRun( hTE, &sel_sta, &sel_end );
  2107.                 else
  2108.                   sel_end = sel_sta = eTeChPosToOffset( hTE, (**hTE).caretChPos );
  2109.               }
  2110.               eTeSetSelect( hTE, sel_end, sel_end );
  2111.               sel_len = sel_end - sel_sta;
  2112.               HLock((**hTE).hText);
  2113.               if (sel_len > 0)
  2114.                 put_input( id, *((**hTE).hText) + sel_sta, sel_len, 1, 0, 1 );
  2115.               else
  2116.                 put_input( id, NULL, 0, 1, 0, 1 ); /*  not done yet!?  12Sep92  e  */
  2117.               HUnlock((**hTE).hText);
  2118.             }
  2119.             else if (c == 9) /*tab*/
  2120.             { eTabCommand( hTE, event->modifiers, wind_table[w].bold_input );
  2121.               eMaybeSmudgeWindow( w, hTE );
  2122.               inval_msgrect( w ); /* 10Jan93  e -- added display of caret position */
  2123.             }
  2124.             else
  2125.             { check_TEKey( c, hTE, wind_table[w].bold_input, event );
  2126.               if ((c == '\r') && (**hTE).autoInd)
  2127.                 eTabCommand( hTE, optionKey, wind_table[w].bold_input );
  2128.               eMaybeSmudgeWindow( w, hTE );
  2129.               inval_msgrect( w ); /* 10Jan93  e -- added display of caret position */
  2130.               if ( (c=='\r' /*cr*/) || (c=='\b' /*bs*/) ) eTeShowCaret( hTE );
  2131.             }
  2132.           }
  2133.           else
  2134.           { check_TEKey( c, hTE, wind_table[w].bold_input, event );
  2135.             eMaybeSmudgeWindow( w, hTE );
  2136.             inval_msgrect( w ); /* 10Jan93  e -- added display of caret position */
  2137.             eTeShowCaret( hTE );
  2138.           }
  2139.         }
  2140.         break;
  2141.       case activateEvt:
  2142.         gCursRgnOK = false;
  2143.           handle_activate( (WindowPtr)event->message, ((event->modifiers & activeFlag) != 0) );
  2144.         break;
  2145.       case updateEvt: 
  2146.         if ((w = wptr_to_id( (WindowPtr)event->message )) >= 0)
  2147.         { update_window(w);
  2148.         }
  2149.         else
  2150.         { GrafPtr port = (WindowPtr)event->message;
  2151.           SetPort( port );
  2152.           BeginUpdate( port );
  2153.           EndUpdate( port );
  2154.         }
  2155.         break;
  2156.       case osEvt:
  2157.         if( *(char *)(&event->message) == suspendResumeMessage )
  2158.         { gCursRgnOK = false; /* Suspend/resume is also an activate/deactivate. */
  2159.           gInBackground = !(event->message & resumeFlag);
  2160.           if( gInBackground ) eTePutScrap();                  /*  13Aug92  e  */
  2161.           else                  eTeGetScrap();                  /*  13Aug92  e  */
  2162.           handle_activate( FrontWindow(), !gInBackground );
  2163.         }
  2164.         /* punt mouseMovedMessage */
  2165.         break;
  2166.       case diskEvt:
  2167.         gCursRgnOK = false;                     /* It is not a bad idea to at least call */
  2168.         if (HiWord(event->message) != noErr) /* DIBadMount in response to a diskEvt,  */
  2169.         { Point pt;                             /* so that the user can format a floppy. */
  2170.           SetPt( &pt, kDILeft, kDITop );
  2171.           DIBadMount( pt, event->message );
  2172.         }
  2173.         break;
  2174.       /* 29Dec92  e  */
  2175.       case kHighLevelEvent:
  2176.         AEProcessAppleEvent(event);
  2177.         if (gDoQuit) os_quit();
  2178.         break;
  2179.       default: ;
  2180.     }
  2181.   }
  2182.   return 1;
  2183. }
  2184.  
  2185. long os_get_next_event( EventRecord *event )
  2186. { long result = 0;
  2187.   GrafPtr save;
  2188.   GetPort( &save );
  2189.   if (do_tasks())
  2190.   { if (gHasWNE)
  2191.       { result = (long)( gInBackground ? gWaitTicksBG    /* 22Jul92  e   -- added gMaxSleep */
  2192.                                          : (long )( (gWaitTicksFG > gMaxSleep) ? gMaxSleep
  2193.                                                                                 : gWaitTicksFG) );
  2194.       result = WaitNextEvent( everyEvent, event, result, gCursorRgn );
  2195.     }
  2196.     else
  2197.     { SystemTask();
  2198.       result = GetNextEvent( everyEvent, event );
  2199.     }
  2200.   }
  2201.   SetPort( save );
  2202.   return result;
  2203. }
  2204.  
  2205. long os_handle_event( EventRecord *event )
  2206. { long result;
  2207.   GrafPtr save;
  2208.   GetPort( &save );
  2209.   result = handle_event( event );
  2210.   SetPort( save );
  2211.   return result;
  2212. }
  2213.  
  2214. void os_event_check( void )            /* 25Jan93  e  */
  2215. { EventRecord event;
  2216.   os_get_next_event( &event );
  2217.   os_handle_event( &event );
  2218.   next_eventchk_ticks = Ticks + TicksBetweenEventChecks;
  2219. }
  2220.  
  2221. void os_quit()
  2222. { short i;
  2223.   long ticks;
  2224. #if 0
  2225.   stop_intr_task();
  2226.   for (i=MAX_NB_OPEN_FILES-1; i>0; i--) os_file_close( (OS_FILE)i );
  2227.   if (abnormal_exit)
  2228.   { for (i=0; i<3; i++) { SysBeep(3); Delay( 3, &ticks ); }
  2229.     Delay( 60, &ticks );
  2230.   }
  2231. #endif
  2232.   wind_end();
  2233.   /* was: ExitToShell();  for Tricia: */
  2234.   exit(0);
  2235. }
  2236.  
  2237. /* ******* console io ******* */
  2238.  
  2239. #if 0
  2240. void os_flush_caches()
  2241. { if (gHasHWPriv)
  2242.   asm
  2243.   { moveq #1,d0
  2244.     dc.w _HWPriv
  2245.   }
  2246. }
  2247. #endif
  2248.  
  2249. static short main_internal( )
  2250. { short i;
  2251.   MaxApplZone();
  2252.   for (i = 0; i < 10; i++)
  2253.         MoreMasters();
  2254.   /* CouldAlert( ok_alertID ); */
  2255.   SetGrowZone( mem_full_err );
  2256.  
  2257.   wind_begin();
  2258.  
  2259. #if 0
  2260.   GetVol( new_args, ¤t_volume );
  2261.   if (!getfullpathfromcurrentvolume( CurApName, new_args, 256, 0 ))
  2262.     p_to_c( CurApName, new_args );
  2263. #endif
  2264.  
  2265.   SetCursor( current_cursor );
  2266.  
  2267.   ParamText1( "\p" );
  2268.  
  2269. #if 0
  2270.   loading_dp = GetNewDialog( loading_dlogID, 0L, (WindowPtr)-1L );
  2271.   if (loading_dp != NULL) DrawDialog( loading_dp );
  2272. #endif
  2273.  
  2274.   return 0;
  2275. }
  2276.  
  2277. static short console_initialized = 0;
  2278.  
  2279. WindowPeek os_console_new( unsigned char *name )
  2280. { char cname[256];
  2281.   short id;
  2282.   WindowPeek wp;
  2283.   if( !console_initialized )
  2284.   { main_internal();
  2285.     console_initialized = 1;
  2286.   }
  2287.   p_to_c( name, cname );
  2288.   id = wind_open( cname, FALSE, FALSE, TRUE );
  2289.   if( id < 0 ) return (WindowPeek )0;
  2290.   interaction_id = id;
  2291.   delWindMenuItem( interaction_id );
  2292.   wp = (WindowPeek )wind_table[id].wptr;
  2293.   wp->refCon = (long )id;
  2294.   return(wp);
  2295. }
  2296.  
  2297. long os_console_read( WindowPeek wp, unsigned char *ptr, long cnt )
  2298. { long result = 0;
  2299.   GrafPtr save;
  2300.   GetPort( &save );
  2301.   if( cnt > 0 )
  2302.   { register unsigned char *p1 = ptr;
  2303.     short id = wp->refCon;
  2304.     EventRecord event;
  2305.     do
  2306.     { os_get_next_event( &event );
  2307.       os_handle_event( &event );
  2308.       if( interrupted )
  2309.         goto ocr_done;
  2310.       else
  2311.       { register unsigned char *p2 = (unsigned char *)wind_table[id].buf + wind_table[id].pos;
  2312.         register long len = wind_table[id].len - wind_table[id].pos;
  2313.         register short i = 0;
  2314.         if (len > cnt) len = cnt;
  2315.         while ( i < len )
  2316.         { register unsigned char c = p2[i++];
  2317.           if (c == '\r')
  2318.           { c = '\n';
  2319.             len = i; /* to exit inner loop */
  2320.             cnt = i; /* to exit outer loop */
  2321.           }
  2322.           *p1++ = c;
  2323.         }
  2324.         wind_table[id].pos += i;
  2325.         cnt -= i;
  2326.         result += i;
  2327.       }
  2328.     } while( cnt > 0 );
  2329.   }
  2330. ocr_done:
  2331.   SetPort( save );
  2332.   return result;
  2333. }
  2334.  
  2335. long os_console_write( WindowPeek wp, unsigned char *ptr, long cnt)
  2336. { long result = 0;
  2337.   GrafPtr save;
  2338.   short id = (short )wp->refCon;
  2339.   register unsigned char *p1 = ptr, *p2 = ptr+cnt;
  2340.   register short len = wind_table[id].out_len;
  2341.   register unsigned char *p3;
  2342.   if( wind_table[id].out_buf == NULL )
  2343.   { wind_table[id].out_buf = NewHandle( OUT_BUF_LEN );
  2344.     if( wind_table[id].out_buf == NULL )
  2345.     { SysBeep(10);
  2346.       return result;
  2347.     }
  2348.   }
  2349.   HLock( wind_table[id].out_buf );
  2350.   p3 = (unsigned char *)*wind_table[id].out_buf;
  2351.  
  2352.   if (!(wp->visible))
  2353.     select_and_show( wp );
  2354.  
  2355.   GetPort( &save );
  2356.   while( p1 < p2 )
  2357.   { register unsigned char c = *p1++;
  2358.     if (c == '\n') { p3[len++] = '\r'; goto output; }
  2359.     p3[len++] = c;
  2360.     if (len == OUT_BUF_LEN)
  2361.     { output:
  2362.       if( check_TEWrite( (char *)p3, (long)len, wind_table[id].hTE, 0 ) ) goto werror;
  2363.       wind_table[id].out_len = 0;
  2364.       len = 0;
  2365.     }
  2366.   }
  2367.   wind_table[id].out_len = len;
  2368.   result = cnt;
  2369. werror:
  2370.   SetPort( save );
  2371.   HUnlock( wind_table[id].out_buf );
  2372.   return result;
  2373. }
  2374.  
  2375. long os_console_close( WindowPeek wp )
  2376. { long result = 0;
  2377.   GrafPtr save;
  2378.   short id = (short )wp->refCon;
  2379.   GetPort( &save );
  2380.   if( id < 0 )
  2381.     result = -1;
  2382.   else
  2383.     wind_close( id );
  2384.   SetPort( save );
  2385.   return result;
  2386. }
  2387.  
  2388. /*--------------------------------------------------------------------------*/
  2389.  
  2390. /* new stuff  29Dec92  e  */
  2391.  
  2392. /* Used to check for any unread required parameters. Returns true if we
  2393. ** missed at least one. */
  2394.  
  2395. static Boolean    MissedAnyParameters(AppleEvent *message)
  2396. {
  2397.     OSErr        err;
  2398.     DescType    ignoredActualType;
  2399.     AEKeyword    missedKeyword;
  2400.     Size        ignoredActualSize;
  2401.     EventRecord    event;
  2402.  
  2403.     err = AEGetAttributePtr(    /* SEE IF PARAMETERS ARE ALL USED UP.          */
  2404.         message,                /* AppleEvent to check.                          */
  2405.         keyMissedKeywordAttr,    /* Look for unread parameters.                  */
  2406.         typeWildCard,            /* So we can see what type we missed, if any. */
  2407.         &ignoredActualType,        /* What it would have been if not coerced.      */
  2408.         (Ptr)&missedKeyword,    /* Data area.  (Keyword not handled.)          */
  2409.         sizeof(missedKeyword),    /* Size of data area.                          */
  2410.         &ignoredActualSize        /* Actual data size.                          */
  2411.     );
  2412.  
  2413. /* No error means that we found some unused parameters. */
  2414.  
  2415.     if (err == noErr) {
  2416.         event.message = *(long *) &ignoredActualType;
  2417.         event.where = *(Point *) &missedKeyword;
  2418.         err = errAEEventNotHandled;
  2419.     }
  2420.  
  2421. /* errAEDescNotFound means that there are no more parameters.  If we get
  2422. ** an error code other than that, flag it. */
  2423.  
  2424.     return(err != errAEDescNotFound);
  2425. }
  2426.  
  2427. static OSErr    OpenDocEventHandler(AppleEvent *message, AppleEvent *reply, short mode)
  2428. {
  2429.     OSErr        err;
  2430.     OSErr        err2;
  2431.     AEDesc        theDesc;
  2432.     FSSpec        theFSS;
  2433.     short        loop;
  2434.     long        numFilesToOpen;
  2435.     AEKeyword    ignoredKeyWord;
  2436.     DescType    ignoredType;
  2437.     Size        ignoredSize;
  2438.     char path[512];
  2439.     short w;
  2440.     Str255 flnm;
  2441.     FInfo theFInfo;
  2442.  
  2443.     theDesc.dataHandle = nil;
  2444.         /* Make sure disposing of the descriptors is okay in all cases.
  2445.         ** This will not be necessary after 7.0b3, since the calls that
  2446.         ** attempt to create the descriptors will nil automatically
  2447.         ** upon failure. */
  2448.  
  2449.     if ( err = AEGetParamDesc( message, keyDirectObject, typeAEList, &theDesc ) )
  2450.         return(err);
  2451.  
  2452.     if ( ! MissedAnyParameters( message ) ) {
  2453.  
  2454. /* Got all the parameters we need.  Now, go through the direct object,
  2455. ** see what type it is, and parse it up. */
  2456.  
  2457.         err = AECountItems(&theDesc, &numFilesToOpen);
  2458.         if (!err)
  2459.         {    /* We have numFilesToOpen that need opening, as either a window
  2460.             ** or to be printed.  Go to it... */
  2461.  
  2462.             for (loop = 1; ((loop <= numFilesToOpen) && (!err)); ++loop)
  2463.             {    err = AEGetNthPtr(        /* GET NEXT IN THE LIST...         */
  2464.                     &theDesc,            /* List of file names.             */
  2465.                     loop,                /* Item # in the list.             */
  2466.                     typeFSS,            /* Item is of type FSSpec.         */
  2467.                     &ignoredKeyWord,    /* Returned keyword -- we know.  */
  2468.                     &ignoredType,        /* Returned type -- we know.     */
  2469.                     (Ptr)&theFSS,        /* Where to put the FSSpec info. */
  2470.                     sizeof(theFSS),        /* Size of the FSSpec info.         */
  2471.                     &ignoredSize        /* Actual size -- we know.         */
  2472.                 );
  2473.                 if (err) break;
  2474.  
  2475.                 FSpGetFInfo( &theFSS, &theFInfo );
  2476.                 if ( theFInfo.fdType != 'TEXT' )
  2477.                 { SysBeep( 3 );
  2478.                   continue;
  2479.                 }
  2480.                 gPrintPage = mode;
  2481.                     /* Open the window off-screen if we are printing.
  2482.                     ** We use the gPrintPage global to flag this.  Normally, the
  2483.                     ** gPrintPage global is to tell ImageDocument if we are imaging
  2484.                     ** to the window or to paper.  We don't need it for this yet,
  2485.                     ** as we can't image the document until it is opened.  DoNewWindow()
  2486.                     ** uses gPrintPage as a flag to open the window off-screen, but
  2487.                     ** visible, so that PrintMonitor can use the title of the window
  2488.                     ** as the document name that is being printed. */
  2489.                 
  2490.                 if ( getfullpath( theFSS.vRefNum, theFSS.parID, theFSS.name, path, 511, 1 ) )
  2491.                 {    
  2492.                     w = edit( path, 0L, 0L );
  2493.  
  2494.                     if ( gPrintPage && w >= 0 )
  2495.                     {    pathstr_to_filename( wind_table[w].filename, flnm );
  2496.                         err  = eTePrint( wind_table[w].hTE, (mode == 2), (loop == 1), flnm );
  2497.                         mode = 1;    /* No interaction mode (mode == 2) only valid
  2498.                                     ** for the first printed document. */
  2499.                         wind_close( w );
  2500.                     }
  2501.                 }
  2502.                 else err = errAEEventNotHandled;     /* file pathname too long */
  2503.             }
  2504.             if (gPrintPage)
  2505.             {    eTePrint( nil, false, false, flnm ); /* cleanup */
  2506.                 gPrintPage = 0;                      /* back to normal */
  2507.             }
  2508.         }
  2509.     }
  2510.     err2 = AEDisposeDesc(&theDesc);
  2511.     return(err ? err : err2);
  2512. }
  2513.  
  2514. static Boolean install_aehandler( AEEventClass cl, AEEventID id, ProcPtr p )
  2515. { OSErr    err;
  2516.   err = AEInstallEventHandler( cl, id, p, 0L, false );
  2517.   if (err)
  2518.   { io_err(err);
  2519.     return false;
  2520.   }
  2521.   return true;
  2522. }
  2523.  
  2524. static pascal OSErr    DoAEOpenApplication( AppleEvent *message, AppleEvent *reply, long refcon )
  2525. {
  2526.     return(noErr);
  2527. }
  2528.  
  2529. static pascal OSErr    DoAEOpenDocuments( AppleEvent *message, AppleEvent *reply, long refcon )
  2530. {
  2531.     gCursRgnOK = false;
  2532.     return( OpenDocEventHandler( message, reply, 0 ) ); /* 0 means regular open document */
  2533. }
  2534.  
  2535. #define kTimeOutInTicks (60 * 30)    /* 30 second timeout. */
  2536.  
  2537. static pascal OSErr    DoAEPrintDocuments(AppleEvent *message, AppleEvent *reply, long refcon)
  2538. {
  2539.     short                openMode;
  2540.     ProcessSerialNumber    cpsn, fpsn;
  2541.     Boolean                procsSame;
  2542.  
  2543.     gCursRgnOK = false;
  2544.     openMode = 1;
  2545.     if (!AEInteractWithUser(kTimeOutInTicks, nil, nil))
  2546.         ++openMode;
  2547.  
  2548.     GetCurrentProcess(&cpsn);        /* We may have been moved to the front. */
  2549.     GetFrontProcess(&fpsn);
  2550.     SameProcess(&cpsn, &fpsn, &procsSame);
  2551.     gInBackground = !procsSame;
  2552.  
  2553.     return( OpenDocEventHandler( message, reply, openMode ) );
  2554.         /* openMode is either 1 or 2, depending if user interaction is okay. */
  2555. }
  2556.  
  2557. static pascal OSErr    DoAEQuitApplication( AppleEvent *message, AppleEvent *reply, long refcon )
  2558. {
  2559.     gCursRgnOK = false;
  2560.     wind_quit();
  2561.     return( gDoQuit ? noErr : errAEEventNotHandled );
  2562. }
  2563.  
  2564. /* 1Feb93  e  --  DoScript added */
  2565.  
  2566. static OSErr DoScriptAsFile( FSSpec *theFSS )
  2567. {
  2568.     OSErr err = noErr;
  2569.     char  path[512];
  2570.     
  2571.     if( getfullpath( theFSS->vRefNum, theFSS->parID, theFSS->name, path, 511, 1 ) )
  2572.     {
  2573.         put_input( interaction_id, " use \"", 6, 0, 0, 1 );
  2574.         put_input( interaction_id, path, strlen(path), 0, 0, 0 );
  2575.         put_input( interaction_id, "\";", 2, 1, 0, 0 );
  2576.     }
  2577.     else err = errAEEventNotHandled;
  2578.     return err;
  2579. }
  2580.  
  2581. static pascal OSErr DoAEDoScript( AppleEvent *theAEEvent, AppleEvent *theAEReply, long *theRefCon)
  2582. {
  2583.     OSErr        theErr;
  2584.     DescType    typeCode;
  2585.     Size        sizeOfParam, actualSize;
  2586.     char        ourScriptText[256];
  2587.     FSSpec        ourScriptFSpec;
  2588.  
  2589.     /* Get the script to run */ 
  2590.  
  2591.     theErr = AESizeOfParam( theAEEvent, keyDirectObject, &typeCode, &sizeOfParam);
  2592.     if (theErr != noErr)
  2593.     {    /*
  2594.             If we fail here just return the error. We don't need to do any clean up since 
  2595.             we've allocated nothing on the heap yet.  The Apple Event Manager automatically 
  2596.             adds the error number to the reply as keyErrorNumber for non zero handler returns.
  2597.         */
  2598.         return theErr;
  2599.     }
  2600.     else if ((typeCode == typeChar) || (typeCode == typeStyledText) || (typeCode == typeIntlText))
  2601.     {
  2602.         theErr = AEGetParamPtr( theAEEvent, keyDirectObject, typeChar, &typeCode,
  2603.                                  (Ptr)&ourScriptText, sizeof(ourScriptText), &actualSize);
  2604.         if (theErr == noErr)
  2605.             if ( MissedAnyParameters( theAEEvent ) )
  2606.                 theErr = errAEEventNotHandled;
  2607.             else put_input( interaction_id, ourScriptText, actualSize, 1, 0, 1 );
  2608.     }
  2609.     else if (typeCode == typeAlias)
  2610.     {
  2611.         theErr = AEGetParamPtr( theAEEvent, keyDirectObject, typeFSS, &typeCode,
  2612.                                 (Ptr)&ourScriptFSpec, sizeof(ourScriptFSpec), &actualSize);
  2613.         if ( theErr == noErr )
  2614.             if ( MissedAnyParameters( theAEEvent ) )
  2615.                 theErr = errAEEventNotHandled;
  2616.             else theErr = DoScriptAsFile( &ourScriptFSpec );
  2617.     }
  2618.     else theErr = errAEEventNotHandled;
  2619.     return theErr;
  2620. }
  2621.  
  2622.  
  2623. static void init_ae()
  2624. {
  2625.     long    result;
  2626.  
  2627.     gHasAppleEvents = (Gestalt(gestaltAppleEventsAttr, &result) ? false : result != 0);
  2628.  
  2629.     if (gHasAppleEvents)
  2630.          install_aehandler( kCoreEventClass, kAEOpenApplication, (ProcPtr)DoAEOpenApplication )
  2631.       && install_aehandler( kCoreEventClass, kAEOpenDocuments, (ProcPtr)DoAEOpenDocuments )
  2632.       && install_aehandler( kCoreEventClass, kAEPrintDocuments, (ProcPtr)DoAEPrintDocuments )
  2633.       && install_aehandler( kCoreEventClass, kAEQuitApplication, (ProcPtr)DoAEQuitApplication )
  2634.       && install_aehandler( kAEMiscStandards, kAEDoScript, (ProcPtr)DoAEDoScript );
  2635. }
  2636.  
  2637. /*--------------------------------------------------------------------------*/
  2638.  
  2639.